Onek8/LNXSDK
1
0
Fork 0
forked from LeenkxTeam/LNXSDK
Code Pull Requests Activity

Update Files

Browse Source
This commit is contained in:
Onek8
2025-01-22 16:18:30 +01:00
parent ed4603cf95
commit a36294b518
16718 changed files with 2960346 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Kha/Backends/Kinc-hxcpp/khacpp/.clang-format Normal file
View File

@ -0,0 +1,2 @@
DisableFormat: true
SortIncludes: false

650
Kha/Backends/Kinc-hxcpp/khacpp/Changes.md Normal file
View File

@ -0,0 +1,650 @@
4.3
------------------------------------------------------------
* Bug fixes
* Upgrade to 4.3 API
* Use PCRE v2
4.2
------------------------------------------------------------
* Update MIN_IOS_VERSION
* Bug fixes
* Upgrade to 4.2 API
* Fixed mysql_select_db failing for newer mariadb versions due to extra 0x00 byte after database
* Fixed mysql_close not sending COM_QUIT before closing socket
4.1.15
------------------------------------------------------------
* Added Arm64 suport on windows
* Fixed crash with zero-sized alloc and generational GC
* Fixed crash with generational GC when old objects come back to life
* Fixed compile error with @:fixed Anons and arrays (socket select)
* Fixed lastIndexOf
* Optimized some equality functions
4.1.1
------------------------------------------------------------
* Added functions for haxe 4.1 Api.
* Added HXCPP_DEBUG_LINK_AND_STRIP to preserve symbolic information when creating android release binaries.
* Added optional HXCPP_SIGNAL_THROW to convert memory errors to haxe exceptions without needing additional code
* Added string_hash_map_substr and __hxcpp_parse_substr_float/int to allow some substring processing without extra allocation
4.0.64
------------------------------------------------------------
* Upgrade buildserver to 4.01
* Better generational collection in high fragmentation case
* typeinfo include fix for MSVC
* Fix MySQL connections
* Fix bugs with HXCPP_GC_GENERATIONAL
* Add map.clear
* Better c++11 iOS support
4.0.19
------------------------------------------------------------
* Add Array.keyValueIterator
* General Utf16 string improvements
* Limit the amount of recursion in toString function
* Add float32 support to cppia
* Fix Gc race condition
* Throw exceptions according to the spec when casting
* Introduce hxcpp_smart_strings for unicode text
4.0.4
------------------------------------------------------------
* Compile Cppia against haxe 4.0 preview 4
4.0.2
------------------------------------------------------------
* Default Cppia to 64 bits on windows
4.0.1
------------------------------------------------------------
* More logic for determining the android NDK version
* Updated various opensource libraries (thanks robocoder)
* Updated version of zlib
* Updated version of sljit
* Updated version of pcre
* Updated version of sqlit3
* Updated version of mbedtls
* Some work on supporting utf16 strings (hx_smart_strings)
* Added process_kill
* Change root when calculating haxelib in build.xml files
* Fix cppia super calls across cpp boundary
* Add Array.resize
* Be consistent with mod in cppia
* Fix Sys.stderr
* Add 'embedName' file attribute to allow text to cpp conversion
* Updates for Msvc
* Updates for Xcode
3.4.188
------------------------------------------------------------
* Fix some threading crashes
3.4.185
------------------------------------------------------------
* Do not ship static libraries
* Use more lock-free structures in GC processing
* Added some documentation
* Added HXCPP_GC_SUMMARY option
* Added HXCPP_GC_GENERATIONAL option
* Added HXCPP_GC_DYNAMIC_SIZE option
* Some MSVC 2017 support
* Compile Cppia with JIT as an option by default
3.4.64
------------------------------------------------------------
* Fixed cppia native interface implementation
* Fixed debugger breakpoints
* More compatibility for inet_pton and inet_ntop
* Correct the order of thread housekeeping data
3.4.49
------------------------------------------------------------
* Fixed 2d-Arrays and unserialize
3.4.43
------------------------------------------------------------
* Added more options for code-size optimizations on android (thanks madrazo)
* Added version of stpcpy on android to allow building with platform > 21, and running on older devices
* Added some initial support for ipv6
* Experimental support for Cppia JIT
* Fixed issue with stale objects that use new pch files in cache
* Rethrowing exception now preserves stack correctly
3.4.2
------------------------------------------------------------
* Align float reads from memory for Arm architecture
* Removed some virtual functions not needed by newer versions of haxe
* Reworked the logic for compacting fragmented heaps with HXCPP_GC_MOVING
* Expose StackContext to allow inlining of allocation routine, and combine with Cppia context
* Fix some compare-with-dynamic issues
* Added WatchOs support
* Fixed for android NDK 13
* Fix Array closure equality
* Refactor the Cppia code
* Fix return codes for atomic decrease
* Fix some GC zone issues in the standard library
* Set minimum MacOS deployment target to 10.6
* Do not use typedefs for 'Int' and 'Bool' for newer api levels
* Added dll_link to create output dll
* Improved ObjC support
* Make Cppia order of operations of '+=' et al consistent with other targets
* Added NO_RECURSE flag to PCRE
* Fix bsd_signal undefines on android
* Add create/free abstract
3.3.49
------------------------------------------------------------
* Fix Dynamic != for haxe 3.2.1
* Fix Command line parsing on windows for triple quotes
3.3.45
------------------------------------------------------------
* Much better compile cache support
* Added tags to compiler flags to allow better targeting
* Added UCP support to regexp
* Added Array::fromData
* Added AtomicInt operations
* Added _hx_imod
* More improvements for tvos
* Fix blocking deque issue
* Improved native testing
* Added 'hxcpp run hxcpp cache ...' commands for managing cache
* Added cpp.Variant class for query of field values to avoid boxing
* Added more efficient version of finalizer
* Add non allocating version of __hxcpp_print
* More WinRT fixes
* Output 'HxcppConfig.h' with defines included for easier external integration
* Output list of output files if requested
* Add support functions for StdLib - alloc/free/sizeof
* Fix crash when marking stack names from GCRoots
* Add bitcode support for iOS
* Rename RegisterClass to avoid conflicts with windows
* Added 'VirtualArray' for arrays of unknown types
* Split Macros.tpl
* Added optional ShowParam to process_run
* Added inline functions for Int64 externs
* Add error check for allocating from a finalizer
* Fix null strings on Cffi Prime
* Use slow path if required for Win64 Tls
* Expand logic for detecting android toolchain from NDK name
* Remove the need for hxcpp binaries by compiling source directly into target
* Adjust the default verbosity level, and add HXCPP_VERBOSE/HXCPP_QUIET/HXCPP_SILENT
* Added some control options for copyFile directive
* Fix cppia decrement
* Add Array.removeRange, which does not require a return value
* Do not call setbuf(0) on stdin, since it messes with readLine
* Cppia now throws an error if loading fails
* Allocate EnumParam data inline to cut down on allocations
* Allow anonymous object data to be allocated inline to avoid allocations
* Add SSL library code
* Add NativeGen framework for interfaces
* Add macros to allow neater generated code
* Allow larger memory space with -D HXCPP_GC_BIG_BLOCKS
* Improve Array.join speed
3.2.205
------------------------------------------------------------
* Initial support for HXCPP_OPTIMIZE_FOR_SIZE
* Support HXCPP_DEBUG_LINK on more targets
* Support for cross compiling to windows from linux
* Added array removeAt
* Some telemety fixes (thanks Jeff)
* Check contents when comparing Dynamics with same pointer (Math.Nan!=Math.Nan)
* Numerous WinRT fixes (thanks madrazo)
* Fixed bug causing GC to crash marking constant strings (eg, resources)
* Updated default SDK for Tizen (thanks Joshua)
* Fixed command line args on linux (thanks Andy)
3.2.193
------------------------------------------------------------
* Some improvements for tvos
* Start on some GC defragging code
* Fix android thread access to GC structures
* Add socket socket_recv_from and socket_send_to
* Fixed memory leak in GC collection code
* Allow cross-compile to windows via MINGW
* Fix overflow error that meant GC would work with a too-small buffer in some cases
3.2.180
------------------------------------------------------------
* Initial support for tvos
* Change name of ObjectType to hxObjectType to avoid clashes with iOS
* Try to keep windows.h out of haxe-generated code
* Fix null access bug in array-of-array
* Create separate library for msvc 19
------------------------------------------------------------
* Try to get the pdb server working better for MSVS 2015
* So not export symbols on windows unless HXCPP_DLL_EXPORT is set (-D dll_export) - makes exe smaller
* Avoid dynamic-cast if possible when converting 2D arrays
* Some RPi fixes
* Some CFFI Prime fixes (thanks Joshua)
* Fix build tool for next version of neko
* Improve msvc cl.exe version checking for non-English environments
* Add more control over how much Gc memory is used
* Add faster(inline) thread local storage for Gc on windows.
* Add some Gc load balancing when marking large arrays with multiple threads
* Change the Gc memory layout to be a bit larger, but simpler. This allows most of the allocation to be simplified and inlined.
* Explicitly scan registers for Gc references because the stack scanning was missing them sometimes
* Some additions to Undefine.h for windows
* When static linking using MSVC 2015, compile the libraries directly into the exe to avoid compatibility issues
* Move standard libraries into their own build.xml files
* Make it easier to change the generated output filename
* Allow targets from one build.xml file to be merged into another
* Some more work on HXCPP_COMPILE_CACHE
* Allow automatic grouping of obj files into librarys to avoid linking all the symbols in all obj files
* Add implicit conversion to referenced type from cpp.Reference
* Allow build.xml files to be imported relative to importing file
* Allow '-' in command-line defines
* Fix warnings from Hash class
* Fix setsockopt for Mac
* Support to MSVC2015
* Fix for Blackberry 10.3
* Fix debug break by linenumber
* Better objc integration (thanks Caue)
* Increase number of variables captured in closures to 20
* Initial support for telemetry (thanks Jeff)
* Align allocations for better emscripten support
------------------------------------------------------------
* Fix gc_lock error in remove_dir
* Some cppia bug fixes - enum and resources overrides
* More android atof fixes
* Improved haxelib seek logic
Haxe 3.2.0
------------------------------------------------------------
* Improve testing
* Allow dll_load path to be set programatically and simplified the dll search sequence.
* Improved cffi_prime, and added String class
* Fixed static linking of mysql5
* Moved static link code in general to cpp.link package, not hxcpp package
* URL decode now does not need to performe reallocs
* Ensure HXCPP_API_LEVEL is always defined
* Added __hxcpp_unload_all_libraries to cleanly unload dlls
* Added some utc date functions
* Better support for non-console apps in windows XP 64
* Increased use of HXCPP_DEBUG_LINK for gcc based targets
* Class 'hasField' is now more consistent with other functions/targets
* 'haxelib run hxcpp test.cppia' will run Cppia on the specified file
* Add fast-select option for sockets
* Allow code to run without HXCPP_VISIT_ALLOCS defined
* Fix debugger thread deadlocks
* Allow up to 27 dynamic arguments
* Fixes for Emscripten - byte align access and disable threads
* Allow emscripten to generate 'executables' (.js/.html) and add options for specifying memory
* Allow spaces in exe names again
* Make cpp::Struct compare via memcmp, and mark correctly
* Fix catch block in cppia
* Treat '-debug' as an alias for "-Ddebug"
* Expose ArrayBase for use with some generic or external code
* Clarify the role of 'buffer' in cffi
------------------------------------------------------------
* Only put a minimal run.n in source-control, and use this to boot hxcpp.n
* Added cpp.Struct and cpp.Reference classes, which are handy for extern classes
* Moved Class to hx namespace
* Simplified 'main' logic
* Allow new android compilers to work for old devices (thanks google)
* Correctly read hxcpp_api_level from Build.xml
* Verbose logging prints which file is being compiled
* Handle undefining the INT_ constants differently to allow std::string to still compile
* Remove entries form Options.txt that do not influence the cpp build
* Add optional destination= command-line option to allow copying the result to named file
* Static libraries will be prefixed with 'lib' now
* val_is_buffer always returns false on neko
* Add val_iter_field_vals, which is like val_iter_fields but consistent with neko
* Remove NekoApi binaries
* Add Cppia binaries
* Add Windows64 binaries
* Make compares between Dynamic and numeric types false, unless the Dynamic is actaully numeric
------------------------------------------------------------
* Even more optimizations for hashes
* Some more optimizations for small hashes
* Fix for google changing inlining in platform21 headers (atof, rand, srand)
* Re-tuned Hash for small objects too (improves Anon object perforamce)
* Reverted change that automatically threw 'BadCast'. Now required HXCPP_STRICT_CASTS
------------------------------------------------------------
* Cached dynamic versions of small ints and 1-char-strings for speed
* Added support for weak hashes - needs latest haxe version
* Use internal hash structure for maps - now faster. New version of haxe makes it faster still.
* Changed the way development versions are bootstrapped to avoid committing binaries
* Improved mingw support
* Dont append -debug to dll name
* Reorder xml includes to allow early parts to correctly influence older parts
* Fix busy wait in semaphore lock
* Fixed GC issue when constructing exrernal primitive objects
* Added armv7s and arm64 targets for ios
* Some fixes for neko cffi - wstring and warning for neko_init
* Fix file read (and copy) from thread
------------------------------------------------------------
* Compile fix for blackberry
* Pass on haxe_api_level
* Add -nocolor flag
------------------------------------------------------------
* Add support for prelinker
* Cygwin toolchain fix
* Add HXCPP_NO_COLOUR and HXCPP_NO_M32
* Fix windows trace output
* Add initial support for GCWO compile
* Fix bug with losing GC references in Array.sort
* Fix bug with zombie marking
* Add support for optimised sort routines
* Add support for haxe.ds.Vector optimisation
* Add support for cpp.Pointer, cpp.NativeArray, cpp.NativeString
------------------------------------------------------------
* Add BlackBerry and Tizen binaries
* Fix issues when using names like ANDROID or IPHONE in an enum
* Added more info in verbose mode (setenv HXCPP_VERBOSE)
* Refactor build files to allow greater customisation
* Fix bug with 'lock' where some threads may not get released
* Add optimised arrays access
* Add optimised memory operations for arrays and haxe.io.Bytes
* Avoid blocking in gethostbyname
* Upgrade run tool output and layout
* Restore sys_time for windows
3.1.1
------------------------------------------------------------
* Fixed MSVC support for 64-bit targets (vc11, vc12)
* Initial work on cpp.Pointer (not fully functional)
* Fixed callstack when throwing from native function
3.1.0
------------------------------------------------------------
* VC 2013 support - used as default now
* Add winxp compatibility flags
* Allow cross-compiling from mac to linux
* Added NSString helper conversion
* Better auto-detection for android toolchain
* Allow foreign threads to easily attach and detach from GC system
* Weak references to closures keep object alive
* Added HXCPP_API_LEVEL define to allow for future compatibility
* Fixed clearing finalizers twice
* Int multiply and minus are performed with integers now
* Fix comparing +- infinities
* Use multiple threads in the mark phase of GC
* IOS now defaults cpp11 binary linkage
* Added HXCPP_VERBOSE environment var to enable extra output
* Fixed spin loop in pthread_cond_wait
* Added ability to link several .a files into a single .a file
* Removed dependence on STL runtime for supplied modules
* Renamed some directories to be more standard
* Moved some extra build files into obj directory
* Use sys.io.Process instead of Sys.command to avoid threading slowdown writing to console
* Add hxcpp.Builder to help with building multiple binaries
* Add android x86 support
* Drop pre-compiled support for everything excepth windows,mac,linux,ios and android
* Allow libraries and files to accumulated in the build.xml
* Supply pre-build lib files for static linking on supported platforms
* Support for static linking of all modules
* Support for hxcpp-debugger project
* Binaries have been removed from repo, and are built using a server
* Use build.n script to build all appropriate binaries
* Some initial support for mysql and sqlite databases
* Add free_abstract for safe releasing of data references
* Change process lauching to get better thread usage on mac
* Fix GC error in string resources
* Give obj files in libraries unique names
3.0.2
------------------------------------------------------------
* Fix Dynamic + Int logic
* Reverted linux compiler to older version
* Cast Array at call site if required
* Tweak Array.map return value
3.0.1
------------------------------------------------------------
* Added nekoapi for linux64
* Upgrade nekoapi to v2
* Added haxe vector support
* Added socket_set_fast_send
* Fixed android build
* Expanded native memory access methods
* Fix exception dump
* Added initial Emscriptm support
* Allow specification of ANDROID_HOST
* Inital work on auto-setup of win64
* Support call-site casting of Arrays
3.0.0
------------------------------------------------------------
* Support haxe3 syntax
* Added socket poll function
* Added some initial support for dll_import/dll_export
* Allow full path name when loading dynamic libraries
* Allow dynamic toString function
* Added initial support for Raspberry Pi
* Array sort now uses std::stable_sort
* Fixed Dynamic+null string output
* Fix splice size calculation
* Add object ids for use in maps
* Add map/filter functions to arrays
* GC will now collect more often when big arrays are used
* You can specify a number of args > 5 for cffi functions if you want
* Fix internal hash size variable
* Class static field list does not report super members now
* Fix casting of null to any object
* Do not read input twice in sys_getch
* Link in PCH generated obj data on msvs 2012
* Date is now consistent with UTC
* Hash 'remove' now returns correct value
* CPP native WeakRef now works, and has a 'set' function
* Fixed compile error when assigning to a base class
* Fixed compile error when using != and Dynamic
* Math/floor/ceil/trunc/min/max now pass unit tests
* More control over android sdk installation
* Regexp_match fix
* Fix val_callN CFFI
2.10.3
------------------------------------------------------------
* Added initial build support for WinRT
* Android toolchain improvements
* Minor compile fixes
* Other minor improvements
2.10.2
------------------------------------------------------------
* Fixes for BlackBerry 10 compatibility
* Fixes for iOS 6 compatibility
* CFFI improvements
* Minor Linux improvements
* Minor OS X improvements
2.10.1
------------------------------------------------------------
* Fix trace() output
* Clang options for OS X compiler
* Small fixes
2.10.0
------------------------------------------------------------
* GC upgrades - moving/defragging/releasing
* Built-in profiler
* Build-in debugger
* Fix mac ndll finding bug
* Add Int32 member functions
* Clang options for ios compiler
* Add a few pre-boxed constants
* Some general bug fixes
2.09.3
------------------------------------------------------------
* Fix Xml enum usage
2.09.2
------------------------------------------------------------
* Resolve library paths when launching Mac apps from Finder
* Compile fix for the BlackBerry toolchain
* Fix interface comparison
* Fix api_val_array_value for NekoApi
* Add workaround for optional Strings in interfaces
* Tweak the timing og the GC run
* Remove setProperty conditional compiles
* String charCodeAt only returns positive values
* Fix modulo for negative numbers
* Remove extra space from array output
* Treat '.' and '_' as literals in urlEncode
* Dynamically generated, 0 param, enum instances match the static version
2.09
------------------------------------------------------------
* Improved precision in random implementations
* Added some experimental support for float32
* Added some experimental support for generic getProcAddress
* String::fromCharCode generates single-byte strings
* Fix method compares
* Plug memory leak in finalizers
* Fix debug link flags
* Separate get/SetField from get/setProperty
* Added Null<T> for optional parameters
2.08.3
------------------------------------------------------------
* Actually add blackberry toolchain
2.08.2
------------------------------------------------------------
* Add blackberry support
* Add armv7 options
* Support new xcode layout
* Fix const qualifiers on interface functions
* Fix webOS obj directory
2.08.1
------------------------------------------------------------
* Fix Math.random returning 1.0 sometimes
* Std.is( 2.0, Int ) is now true
* Make static library building more separated - refactor defines to control this
* Do not use @files for linking on mac
* toString on Anon objects will now get called
* Fix fast memory access with --no-inline
* Android tool host now set to linux-x86
* Allow use of __compare as operator== overload
* Add toNativeInt
* Add weak references
* Implement some neko/cffi compatibility operations
* Fix mac deployment using environment variable
* Fix reentrant mutexes
* Do not explicitly specify version of g++
* Speedup some code by avoiding dynamic_cast if possible
* Some fixes to allow Android multi-threading in normal operation
2.08
------------------------------------------------------------
* Do not create a new class definition for each member function
* Allow 5 fast and up to 20 slow dynamic function arguments
* Support utf8 class
* Added "Fast Memory" API similar to flash
* Added support for webOS
* Fix uncompress buffers
* Added file to undefined pesky processor macros
* Setup default config in user area
* Auto-detect msvc and iphone version
* Force compilation for mac 10.5
* Some support for cygwin compilers
* Remove Boehm GC as an option
* Integrate properly now with Android ndk-r6
* Make Int32 pass haxe unit tests (shift/modulo)
* Fix bug in "join"
* Fix bug with marking the "this" pointer in closures
* Fix bug with returning NAN from parseFloat
* Fix linux link flags
* Fix bug where string of length 0 would be null
* Made String cca return value consistent
* Added control over @file syntax
* Removed need for nekoapi.ndll
* Allow for neko.so to end in ".0"
2.07
------------------------------------------------------------
* Added initial support for Mac64, Linux64, MinGW and GPH and refactored build tool.
* Return the count of traced objects
* Fix interface operator ==
* Initial work on msvc10 batch file
* Add bounds check on String.cca
* Build static libraries, if requrested
* Added exe stripping
* Added val_field_name, val_iter_fields
* Fixed nekoapi string length
* Fixed Sys.args
2.06.1
------------------------------------------------------------
* Close files if required in GC
* Added fix for File.write
* Fixed String UTF8 Encode
* Nekoapi is now a "ndll", not a "dso".
* Fix array compile issue on linux
* Fix stack setting on firced collect
2.06.0
------------------------------------------------------------
* Updates to match haxe 2.06 compiler features
* Numerous bug fixes
* Add additional context to GC collection process
* Swapped from wchar_t* to utf8 char*
* Added templated iterators
* Use strftime for Dates
* Fix socket select and "_s" members
* Seed Math.random
* Fixed dynamic integer compare
* Added __hxcpp_obj_id
* Added some Android support
2.05.1
------------------------------------------------------------
* Updated windows nekoapi.dll binary
* Added -m32 compile flags to force 32 bit
2.05.0
------------------------------------------------------------
* Default to IMMIX based internal garbage collection.
* Reorginised files - split big ones, and moved common ones out of "runtime".
* Put internal classes in "hx" namespace, or HX_ prefix for macros.
* Remove multiple-inheritance, and use delegation instead.
* Write "Options.txt" from compiler so dependency can be determined.
* Require -D HXCPP_MULTI_THREADED for multi-threaded classes - to avoid overhead if not required.
* Build thread code into executable for better control.
* Fix return values of parseINt/parseFloat.
* Added comprehensive list of reserved member names.
* Put if/else statements in blocks.
* Added assert, NULL, LITTLE_ENDIAN, BIG_ENDIAN as keywords.
* Added control over how fast-cffi routines are created by requiring cpp.rtti.FastIntergerLookup to be "implemented".
* Construct anonymous object fields in deterministic (as declared) order.
* Fix code generation for some complex inline cases.
* Added cpp.zip.Compress
* Change "Reflect" class to be more standard
* Use array of dynamics for StringBuf.
* Fix setting of attributes in XML nodes.
Build-tool:
* Allow multiple build threads (via setenv HXCPP_COMPILE_THREADS N) for faster building on multi-code boxes.
* Added FileGroup dependencies
* Added pre-compiled headers (windows only, at the moment since gcc seems buggy)
1.0.7
-----------------
Changelog starts.

15
Kha/Backends/Kinc-hxcpp/khacpp/LICENSE.txt Normal file
View File

@ -0,0 +1,15 @@
* Copyright (c) 2008 by the contributors
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following condition is met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* See individual source files for additional license information.
*
* THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED.

30
Kha/Backends/Kinc-hxcpp/khacpp/README.md Normal file
View File

@ -0,0 +1,30 @@
# hxcpp
[![Build Status](https://dev.azure.com/HaxeFoundation/GitHubPublic/_apis/build/status/HaxeFoundation.hxcpp?branchName=master)](https://dev.azure.com/HaxeFoundation/GitHubPublic/_build/latest?definitionId=3&branchName=master)
hxcpp is the runtime support for the c++ backend of the [haxe](http://haxe.org/) compiler. This contains the headers, libraries and support code required to generate a fully compiled executable from haxe code.
# building the tools
```
REPO=$(pwd)
cd ${REPO}/tools/run
haxe compile.hxml
cd ${REPO}/tools/hxcpp
haxe compile.hxml
cd $REPO
```
# cppia
You first need to build the cppia host.
```
REPO=$(pwd)
cd ${REPO}/project
haxe compile-cppia.hxml
cd $REPO
```
Then you can do `haxelib run hxcpp file.cppia`.

42
Kha/Backends/Kinc-hxcpp/khacpp/azure-pipelines.yml Normal file
View File

@ -0,0 +1,42 @@
variables:
- group: variables-haxe
- name: AZURE_PIPELINES_REPO_URL
value: $(Build.Repository.Uri)
- name: AZURE_PIPELINES_BRANCH
value: $(Build.SourceBranchName)
- name: HXCPP_COMPILE_CACHE
value: $(Agent.TempDirectory)/hxcache
stages:
- stage: StageTest
jobs:
- template: tools/azure-pipelines/build.yml
parameters:
name: Linux64
vmImage: ubuntu-20.04
platform: linux64
arch: 64
- template: tools/azure-pipelines/build.yml
parameters:
name: Linux32
vmImage: ubuntu-20.04
platform: linux64
arch: 32
- template: tools/azure-pipelines/build.yml
parameters:
name: Mac
vmImage: macOS-10.15
platform: mac
arch: 64
- template: tools/azure-pipelines/build.yml
parameters:
name: Windows64
vmImage: windows-2019
platform: windows
arch: 64
- template: tools/azure-pipelines/build.yml
parameters:
name: Windows32
vmImage: windows-2019
platform: windows
arch: 32

6
Kha/Backends/Kinc-hxcpp/khacpp/build-tool/BuildCommon.xml Normal file
View File

@ -0,0 +1,6 @@
<xml>
<pragma once="true" />
<include name="toolchain/haxe-target.xml" />
</xml>

55
Kha/Backends/Kinc-hxcpp/khacpp/docs/CompileCache.md Executable file
View File

@ -0,0 +1,55 @@
The Hxcpp Cache
---------------
The hxcpp compile cache is used to share object files between projects. This can alleviate the need to ship static libraries with external projects, since developers who use the library can compile the library just once, and then reuse it between projects.
The cache uses a hashing mechanism to tell if the contents of a file or its dependencies has changed, and combines this with the compiler version and flags to make specific object files for each change and each compiler congiguration. This also allows some common haxe runtime and haxe generated files to share their object files between projects, even if in different directories.
Additional benefits include keeping some files outside the source tree, and being able to remove these temp files easily.
### Setup
A directory needs to be set aside to enable the cache. If possible, this should be on fast storage, such as a SSD. This is most easily done with an entry in the .hxcpp_config.xml file:
```xml
<set name="HXCPP_COMPILE_CACHE" value="c:/hxcpp/cache" />
<set name="HXCPP_CACHE_MB" value="4000" />
```
Keeping the path short can help in some border-line cases with some compilers where command-line length can become an issue.
The cache size defaults to 1 Gig. For many cases, this is big enough. However, on large projects, with several architectures and lots of debug information, this default can lead to "cache churn" where some files are evicted from the cache, even though they are likely to be used again. Increasing the number of mega-bytes allocated to the cache can help here.
### Using The Cache
To use the cashe with your own libraries, the files group should have 'cache' entry to tell hxcpp that you have considered dependency issues when designing the group.
```xml
<cache value="true" project="name" asLibrary="true" />
```
- project = name of project used to manage and group object files in the cache
- asLibrary = link the objs into a .lib file.
When linking a file group 'asLibrary', the object files are compiled and then the library tool is used to make a library from these object files. This library is then added to the linker. This has a few implications:
- Object files that to not resolve any symbols directly are not added to the final executable
+ Can make final exe size smaller
+ If the object file only contains a handler that is self-registering via static constructor,
then the constructor may not get called, leading to bugs.
- Can help on some systems where the linker command-line length is an issue.
### Management
When compiling normally, hxcpp will check the cache size and evict the least used files to maintain the specified cache size.
Object files in the cache are grouped into "projects" to make management easier, and the hxcpp build tool can be used to explicitly manage the object files.
```
haxelib run hxcpp cache [command] [project]
Perform command on cache, either on specific project or all. commands:
clear -- remove all files from cache
days #days -- remove files older than "days"
resize #megabytes -- Only keep #megabytes MB
list -- list cache usage
details -- list cache usage, per file
```
Start with
```
haxelib run hxcpp cache list
```
To get an idea of cache usage.

152
Kha/Backends/Kinc-hxcpp/khacpp/docs/ThreadsAndStacks.md Executable file
View File

@ -0,0 +1,152 @@
Threads And Stacks
-------------------
### Conservative, co-operation
Hxcpp uses conservative stop-the-world GC, where the threads need to co-operate.
- Threads must not change GC pointers in the collection phase
- The thread stacks/registers must be scanned for GC pointers
- Threads must not block without letting the GC system know not to wait for them, otherwise GC blocks until end of block
+ call hx::GCEnterBlocking() / gc_enter_blocking() / (cpp.vm.Gc.enterGCFreeZone() from Haxe) before potentially blocking system call (fs, network, etc)
+ call hx::GCExitBlocking() / gc_exit_blocking() / (cpp.vm.Gc.exitGCFreeZone() from Haxe) before making more GC calls
+ Might need to pre-allocate buffers
+ Don't forget the exit blocking on error condition
### Foreign Threads
When you create a thread from haxe, it starts attached. Before a non-haxe created thread can interact with hxcpp, some care must be taken, since GC allocations are done using a GC context per thread, and all threads must respect the stopped world.
- Foreign threads must be attached-detached
- SetTopOfStack(int * inTop,bool inPush)
- *inTop* = pointer to top of stack to attach, or '0' to remove stack
- *inPush* = usually true. recursive attachment/detachment
- Must not change things when the world is stopped
- Must define their stack range for scanning
- If you are attached, you may need to enter/exit gc free zone
- Must release context when done, if no more calls are going to be made
- Make sure local variables are covered in stack
- compiler may reorder, so be careful
- Read documentation because some things, eg audio callbacks, happen on other threads
- You can use other techniques, eg
- create a haxe thread, which blocks waiting for signal
- foreign thread generates request and signals haxe thread
- haxe thread performs job and generates data then signals foreign thread
- foreign picks up data and carries on
### Top of Stack
- To understand how to handle threads, you need a mental picture of the c++ stack
- The stack usually goes "down". That is, if the first stack location is 10000, the next one will be 9999 etc.
- Historical, but consistent. Except for emscripten which goes up - but still use same terminology/picture, just change the less-thans to greater-thans in code.
Say the system starts each program stack at 10000, the stack might look like this, with local variables and arguments pushed on the stack:
```
10000
-----------------------------------------------
9996 startup temp variable
9992 startup temp variable
-- main function --
9988 main return address - order and details of this are ABI specific
9984 char ** argv
9980 int argc
```
Hxcpp then runs it main code, which starts with the macro HX_TOP_OF_STACK, which expands to something like:
```
int t0 = 99;
hx::SetTopOfStack(&t0,false);
...
__boot_all();
__hxcpp_main();
-- main function --
9988 main return address order and details of this are ABI specific
9984 char ** argv
9980 int argc
9976 int t0
-- hx::SetTopOfStack --
records '9976' as top of stack for this thread
```
Later, many generated functions deep, `__hxcpp_main` generates an allocation call which
triggers a collection
```
...
8100 Array<Bullet> bullets
-- alloc Enemy --
...
-- Call collect --
8050 int bottomOfStackTemp
MarkConservative(&bottomOfStackTemp, 9976) -> scans stack from 8050 -> 9976
MarkConservative(Capture registers)
```
Enter/exit use similar technique, where the registers are captured and the bottomOfStack is 'locked-in' when the "enter gc free zone" call is made.
```
8100 Array<Bullet> bullets
-- EnterGCFreeZone --
8088 int bottomOfStackTemp
thread->setBottomOfStack(&bottomOfStackTemp)
thread->captureRegisters()
return
* any changes here will not affect GC
```
Now, when another thread does a collection, the gc-free thread can be scanned from 8088 to 9976, regardless of any stuff happening lower dowsn the stack.
### Not Called From Main
Top of stack can be tricky to get right when a gui framework does not really have a "main".
```
10000
-----------------------------------------------
9996 startup temp variable
9992 startup temp variable
-- main function --
setupWindows(onReadyCallback)......
...
8000
-- onReadyCallback --
7976 int t0
SetTopOfStack(&t0,false) -> 7966
__hxcpp_main();
setOnFrameCallack(haxeOnFrame)
return;
```
Later, the haxeOnFrame callback is trigger, but not "below" `__hxcpp_main`
```
9800 -- haxeOnFrame ---
// Top of stack will be below bottom of stack.
```
Solutions:
- Make sure you get in at top of main
+ may scan too much?
- Ratchet up top-of-stack in callbacks, inForce = false
+ gc_set_top_of_stack(void * inTopOfStack,bool inForce);
- Detach main thread after hxcpp_main and reattach each callback
+ android solution because render callbacks happen on different threads
+ gc_set_top_of_stack(&base,true); // attach
+ gc_set_top_of_stack(0,true); // detach
### Debugging.
- in debug mode, hxcpp will check for calls from unattached threads
- hxcpp can log conservative ranges. With a native debugger you can check the address of
your local variables and ensure they are included.
- hxcpp will scan native objects on the stack, but will not follow non-haxe pointers to other objects, so additional GC roots may be required.

82
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Compiler.md Executable file
View File

@ -0,0 +1,82 @@
Compiler
--------
Compilers are run over each of the changed files in each of the filegroups in a target to create object files, which are then linked into the target. Modification dates or hashes are used to tell if files need recompiling, of if the object file can be reused.
- *flag* - Add single arg to command-line.
```xml
<flag value="value" tag="tag" />
```
+ value = text for flag added to command line
+ tag = optional filter to restrict flag to files with matching tag. See [Tags.md](Tags.md).
- *cflag/cppflag/objcflag/mmflag* - Add flag when compiling specific file types.
```xml
<cflag value="value" />
<cppflag value="value" />
<objcflag value="value" />
<mmflag value="value" />
```
+ cflag = only added to .c files
+ cppflag = only added to .cpp files
+ objcflag = only added to .objc files
+ mmflag = only added to .mm objc++ files
- *pchflag* - Add flag when compiling precompiled header .h files.
```xml
<pchflag value="value" />
```
+ pchflag = Usually `["-x", "c++-header"]` for apple to specify the "identity" of the header
- *pch* - Set the precompiled header style - "gcc" or "msvc".
```xml
<pch value="gcc|msvc" />
```
- *objdir* - set name of directory used to store object files. Should be unique for given set of compiler flags to avoid linking against wrong architecture.
```xml
<objdir value="obj/somewhere" />
```
+ value = usually built programmatically, like `obj/msvc${MSVC_VER}-rt${OBJEXT}${OBJCACHE}${XPOBJ}`
- *output* - Flag used to specifying compiler output name.
```xml
<outflag value="-flag" />
```
+ value = flag value. Note that it should contain a space character
if the actual name should be a separate argument, like "-o ", or "-o"/"-out:" if it does not.
- *exe* = Override the executable command specified in the compiler attribute.
```xml
<exe name="command" />
```
+ name = command. Usually you would use 'path' to add the directory, then this is just the filename part.
- *ext* - Specify the object file extension
```xml
<ext name=".obj" />
```
+ name = extension, including ".". Usually ".o" or ".obj".
- *getversion* - The command-line used to create text describing the version of the compiler.
This is used for working out if the compiler has changed, and therefore the objs need recompiling.
```xml
<getversion value="command" />
```
+ value = command to run. It defaults to `compiler --version` which is usual for gcc based compilers.
Setting it empty will disable caching.
- *section* - Group entries - usually sharing common condition
```xml
<section > </section>
```
- *include* - include compiler options from another file. Most compilers should include `<include name="toolchain/common-defines.xml" />` to add defines used by hxcpp.
```xml
<include name="filename" />
```

90
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Defines.md Executable file
View File

@ -0,0 +1,90 @@
Defines
-------
There are a number of standard defines you can use to control the hxcpp build. Some of these are used by the haxe compiler, and affect then generated code. Others apply to the build tool and affect how the code is compiled.
Defines affecting how the code is generated. These need to be in the command line when calling haxe.
| Define | Meaning |
|-------------------------|--------------------|
| *HXCPP_DEBUGGER* | Add extra macros required by debugger. Usually added automatically be debugger haxelib |
| *HXCPP_GC_GENERATIONAL* | Enable experimental generational garbage collector |
| *annotate_source* | Add additional annotations to source code - useful for developing hxcpp |
| *dll_export* | Export hxcpp runtime symbols |
| *file_extension* | Set the extension (without the dot) of generated files. eg "-D file_extension=mm" for objc++ code |
| *force_native_property* | Make dynamic access of fields call property getters/setters where appropriate |
| *include_prefix* | Place all generated include files in a sub-directory, eg "-D include_prefix=hxinc". Useful for avoiding name clashes |
| *no-compilation* | Generate the code, but do not compile it |
| *no-debug* | Do not generate debug macros in code |
| *nocppiaast* | Use legacy cppia generation instead of new more recent changes |
| *objc* | Generate objective-c++ classes |
| *scriptable* | Enable extra runtime information required for scripting |
Defines affecting how the code is compiled. These can be on the command line when calling haxe, or added via the hxcpp build environment.
| Define | Meaning |
|-------------------------|--------------------|
| *HXCPP_GC_MOVING* | Allow garbage collector to move memory to reduce fragmentation |
| *HXCPP_GC_SUMMARY* | Print small profiling summary at end of program |
| *HXCPP_GC_DYNAMIC_SIZE* | Monitor GC times and expand memory working space if required |
| *HXCPP_GC_BIG_BLOCKS* | Allow working memory greater than 1 Gig |
| *HXCPP_GC_DEBUG_LEVEL* | Number 1-4 indicating additional debugging in GC |
| *HXCPP_DEBUG_LINK* | Add symbols to final binary, even in release mode. |
| *HXCPP_STACK_TRACE* | Have valid function-level stack traces, even in release mode. |
| *HXCPP_STACK_LINE* | Include line information in stack traces, even in release mode. |
| *HXCPP_CHECK_POINTER* | Add null-pointer checks,even in release mode. |
| *HXCPP_PROFILER* | Add profiler support |
| *HXCPP_TELEMETRY* | Add telemetry support |
| *HXCPP_CPP11* | Use c++11 features and link libraries |
| *exe_link* | Generate executable file (rather than dynamic library on android) |
| *static_link* | Generate static library |
| *dll_link* | Generate dynamic library |
Other defines:
| Define | Meaning |
|-------------------------|--------------------|
| *HXCPP_VERBOSE* | Print extra output from build tool. |
| *HXCPP_TIMES* | Show some basic profiling information |
| *HXCPP_NEKO_BUILDTOOL* | Force use of hxcpp.n, rather than compiled BuildTool.exe
| *HXCPP_NO_COLOR* | Do not add colour-codes to tool output |
| *HXCPP_KEEP_TEMP* | Does not delete the files created for file 'embedName' option |
Defines affecting target architecture.
| Define | Meaning |
|-------------------------|--------------------|
| *HXCPP_M32* | Force 32-bit compile for current desktop |
| *HXCPP_M64* | Force 64-bit compile for current desktop |
| *HXCPP_ARMV6* | Compile arm-based devices for armv6 |
| *HXCPP_ARM64* | Compile arm-based devices for 64 bits |
| *HXCPP_ARMV7* | Compile arm-based devices for armv7 |
| *HXCPP_ARMV7S* | Compile arm-based devices for armv7s |
| *HXCPP_LINUX_ARMV7* | Run on a linux ARMv7 device |
| *HXCPP_LINUX_ARM64* | Run on a linux ARM64 device |
| *winrt* | Compile for windowsRt/windows UWP |
| *android* | Compile for android |
| *PLATFORM* | Specify the android platform for NDK compilation |
| *ANDROID_NDK_ROOT* | Specify the location of the android NDK toolchain |
| *ANDROID_NDK_DIR* | Specify the search location for finding the android NDK toolchain |
| *HXCPP_X86* | Compile android for x86 architecture |
| *iphoneos* | Compile for iphone iOS |
| *iphonesim* | Compile for iphone simulator |
| *appletvos* | Compile for apple tvOS |
| *appletvsim* | Compile for apple tvOS simulator |
| *watchos* | Compile for apple watchOS |
| *watchsimulator* | Compile for apple watchOS simulator |
| *webos* | Compile for webOS |
| *tizen* | Compile for Tizen |
| *blackberry* | Compile for Blackberry |
| *emscripten* | Compile for Emscripten |
| *cygwin* | Compile for windows using cygwin |
| *linux* | (Cross) Compile for linux |
| *rpi* | (Cross) Compile for raspberry pi |
| *mingw* | Compile for windows using mingw |
| *HXCPP_MINGW* | Compile for windows using mingw |
| *NO_AUTO_MSVC* | Do not detect msvc location, use the one already in the executable path |
| *HXCPP_WINXP_COMPAT* | Remain compatible with Windows XP. Disables condition variables. No effect on ARM. |

94
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Files.md Executable file
View File

@ -0,0 +1,94 @@
Files
------
The files node defines a group of files that all share the same attributes, including relative directory, default compiler flags and dependencies. The node can be used to define a set of header files on which other files can depend, or a set of source files to be compiled and included in a target.
- *depend* - Declare that all files in the group depend on another file or another file group.
```xml
<depend name="filename" />
<depend files="filesId" />
```
+ name = If the named file changes then then all the files in the group need recompiling.
+ files = If any of the files in the named group changes then then all the files in the group need recompiling.
- *options* - Name of file containing compiler flags. When the cache is not used, Options.txt helps detect when the options have changed, and therefore whether files need recompiling.
```xml
<options name="Options.txt" />
```
- *config* - Name of file to generate that contains the #defines that were active when code was compiled.
```xml
<config name="outfile.h" />
```
- *tag* - Add a default compiler flags tag to all files in group. See [Tags.md](Tags.md).
```xml
<tag value="tag" />
```
- *addTwice* - When compiled to a library, add the library twice to the link line - once at the beginning and once at then end to satisfy linux selective linking.
```xml
<addTwice value="tue" />
```
- *cache* - Use compiler cache for files in group. See [compile cache](../CompileCache.md) for more details.
```xml
<cache value="true" project="name" asLibrary="true" />
```
+ project = name of project used to manage and group object files in the cache
+ asLibrary = link the objs into a .lib file, which can skip unneeded objs, but
will also skip things that rely on static initializers to register handlers, so be careful.
- *include* - Include an external file list
```xml
<include name="filename.xml" />
```
- *section* - Groups block of elements - usually ones that all respect the same if/unless condition.
```xml
<section name="id" /> </section>
```
- *compilerflag* - Add a compilerflag when compiling files in group.
```xml
<compilerflag name="name" value="value" />
<compilerflag value="value" />
```
+ name, value = add 2 flags when compiling
+ value = add 1 flag when compiling
- *nvcc* - This group is compiled with nvcc.
```xml
<nvcc />
```
- *objprefix* - An id prepended to generated obj name to allow alphabetical grouping of similar objs.
```xml
<objprefix value="prefix" />
```
- *precompiledheader* - Use a precompiledheader of given name when compiling group
```xml
<precompiledheader name="name" dir="directory" />
```
+ name = the include used when precompiling these files (without the .h)
+ directory = the location of this file
eg, for `#include <lib/Header.h>`
+ name = "lib/Header"
+ directory = "${haxelib:somelib}/include"
- *file* - Add file to group, with optional attributes
```xml
<file name="filename" tags="tag,tag1" filterout="define" embedName="embed" >
<depend name="filename1" />
<depend name="filename2" />
</file>
```
+ name = name of file - may be absolute or relative to files.dir
+ tags = optional override of group tags. See [Tags.md](Tags.md).
+ filterout = allows files to be skipped at compile-time if the named define exists.
This is useful when the define is set sometime after the file list is parsed.
+ depend name = filename of additional dependency
+ embed = causes the file to be embedded as an extern c++ 'const char *' string constant of the specified name

97
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/HaxeTarget.md Executable file
View File

@ -0,0 +1,97 @@
The Haxe Target
---------------
When compiling from haxe, via hxcpp, a "Build.xml" file is generated in the output directory. The file lists the generated files and dependencies and ultimately includes the "toolchain/haxe-target.xml" file, which describes how to combine these files.
### Include Order
There are a few complications when setting the order in which things are configured, since a particular build might want to:
- set the compiler
- override some compiler settings
- make decisions based on the compiler or settings
- set or use standard file prefixes/suffixes
### Example Sequence
You can see which files are included by setting the HXCPP_VERBOSE define when compiling. One example is for a hypothetical user 'Hugh' on a windows platform:
```
Using makefile: Build.xml
No specified toolchain
- Parsing include: C:/Users/Hugh/dev/hxcpp/toolchain/setup.xml
- Parsing include: C:\Users\Hugh\.hxcpp_config.xml (section "vars")
Using Windows compiler: MSVC
- Parsing include: C:/Users/Hugh/dev/hxcpp/toolchain/finish-setup.xml
- Parsing makefile: C:\Users\Hugh\test\proj\cpp\Build.xml
- Parsing include: C:/Users/Hugh/dev/hxcpp/build-tool/BuildCommon.xml
- Parsing include: C:/Users/Hugh/dev/hxcpp/toolchain/haxe-target.xml
- Parsing include: C:/Users/Hugh/dev/hxcpp/toolchain/msvc-toolchain.xml
- Parsing compiler: C:/Users/Hugh/dev/hxcpp/toolchain/common-defines.xml
- Parsing include: C:\Users\Hugh\.hxcpp_config.xml (section "exes")
```
- setup.xml is read because no custom toolchain is specified, and this just include hxcpp_config
- the 'vars' section of hxcpp_config is read - mainly to setup SDK locations
- the hxcpp build tool then uses internal logic based on host and defines to work out which compiler/toolchain to use
- finish-setup then sets a bunch of standard defines for file-extensions and linking flags based on
the type of toolchain being used.
- The provided buildfile (Build.xml) is then processed. It can use the standard defines from finish-setup.
- Build.xml imports the standard haxe-target buildfile, which adds standard runtime files
- The toolchain file is then parsed - making use of any settings from the main Build.xml and finish-setup.
- This file includes the "common-defines.xml" from the compiler to inject standard haxe compiler flags
- hxcpp_config "exe" is parsed. Historically to add libraries or build-paths to targets.
### Standard Environment
finish-setup.xml is where the conventions are set. These variables include:
- haxelink = dll|static_link|exe
- LIBPREFIX = lib|""
- LIBEXTRA =
+ .iphonesim-64
+ .iphonesim
+ .iphoneos
+ .iphoneos-v7
+ .iphoneos-v7s
+ .iphoneos-64
+ .appletvsim-64
+ .appletvsim
+ .watchos
+ .watchsimulator
+ -x86
+ -v7
+ -64
- HX_LINK_SUFFIX = LIBEXTRA | -19 (msvc 19)
- LIBEXT = .a|.lib
- DBG = ""|"-debug"
- OBJEXT = "-list-of-config-ids" depending on available options
These variables are used by haxe-target - you can use them too. Haxe then builds the "haxe" target, which uses some code like:
```xml
<set name="HAXE_OUTPUT_FILE" value="${LIBPREFIX}${HAXE_OUTPUT_PART}${DBG}" />
<target id="haxe" tool="linker" toolid="${haxelink}" output="${HAXE_OUTPUT_FILE}">
<ext value="${LIBEXTRA}.a" if="static_link" />
<!-- ... -->
<files id="__main__" unless="static_link" />
<files id="__lib__" if="static_link"/>
<files id="__resources__" />
<files id="__externs__" />
<files id="runtime" unless="dll_import" />
<files id="cppia" if="scriptable" />
<lib name="-lpthread" if="linux" unless="static_link" />
<lib name="-ldl" if="linux" unless="static_link" />
</target>
```
Here you can see the various file groups, which are enabled or not depending on the compiler mode, and some standard libraries that are needed for Linux.
### Experimenting With Hxcpp Generated Code/Build.xml
If you are using external cpp code, or using meta-data to inject xml into the build process, and you are getting a compile or link error, then it can be useful to run the hxcpp build tool without re-running haxe. This lets you hand-edit the build file or generated c++ code until you get things to work. Once you have solved the issues using this technique, then you can move the changes back into the injected/external code.
First, compile haxe with '-v' flag. This gives quite a bit of debug, but will include a line like this:
```
haxelib run hxcpp Build.xml haxe -Dhaxe3="1" -Dhaxe_ver="4.000" -Dhxcpp_api_level="332" -Dsource-header="Generated by Haxe 4.0.0" -I"" -I"C:/Users/Hugh/dev/haxe/std/cpp/_std/" -I"C:/Users/Hugh/dev/haxe/std/"
```
To use this, first change directories to your output directory. This will be the one you specified with the "-cpp" haxe compiler option. Then, cut and paste this command into a shell, cmd or batch file.

86
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Linker.md Executable file
View File

@ -0,0 +1,86 @@
Linker
------
Generally one linker is run per target to build a static library, dynamic library or exe. The 'id' attribute of the linker specifies whch type of linking is performed.
- *exe* - Overwrite the exe command for this linker.
```xml
<exe name="command" />
```
- *flag* - Add a single link flag.
```xml
<flag value="flag"/>
```
- *ext* - Default extension for generated files - if not overridden by target.
```xml
<ext value=".ext"/>
```
+ value = extension, including "."
- *outflag* - Flag for specifying linker output name.
```xml
<outflag value="-o"/>
```
+ value = linker flag. Note that it should contain a space character
if the actual name should be a separate argument, like "-o ", or "-o"/"-out:" if it does not.
- *section* - Group items - usually sharing common condition
```xml
<section > </section>
```
- *libdir* - A temp directory name to build into. This will capture the extra files the compiler
generates, and then the desired file will be copied to the correct location.
```xml
<libdir name="name"/>
```
- *lib* - Add a library to the link line.
```xml
<lib (name|hxbase|base)="libName" />
```
+ name = the complete name is specified
+ base = the name without compiler-specific extension (.a/.lib) is specified
+ hxbase = the name without extension and architecture (-v7/.iphoinesim) is specified
- *prefix* - Prefix for generated files.
```xml
<prefix value="lib"/>
```
+ value = prefix. This will usually be "lib" or nothing.
- *ranlib* - Whether ranlib needs to be run, and what command to use. Usually only for unix-style static libraries
```xml
<ranlib name="ranlib command"/>
```
- *libpathflag* - Flag used for adding library paths to command line. It will be combined with *lib* entries.
```xml
<libpathflag value="-L"/>
```
- *recreate* - Whether to delete the target file before re-running link command.
The archive "ar" command likes to add obj files to existing archives, so deleting first can help.
```xml
<recreate value="true"/>
```
- *expandAr* - Whether to extract the individual obj files from an archive and add these, rather than
add the archive as a single library. Can solve some link-order and static-initialization issues,
but may make final exe bigger.
```xml
<expandAr value="true"/>
```
- *fromfile* - If the linker supports taking a list of objs in a file, then this is flag for specifying the file.
```xml
<fromfile value="flag" needsQuotes="true" />
```
+ value = flag for specifying file.
If the filename should be a separate argument, then the flag should end with a space.
Usually `@` or `-filelist `. Use empty to disable.
+ needsQuotes = is whether to quote the obj names in the file

79
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/README.md Executable file
View File

@ -0,0 +1,79 @@
Build.xml
----------
The hxcpp build.xml build system is designed to make compiling, cross-compiling and linking easy on a large variety of operating systems and devices. It was originally designed to build the haxe-generated c++ code but has evolved to replace the need for configuration tools in many open source libraries.
### Running
The source code for the tool lives in "tools/hxcpp" in this repo. When compiled, it can be run with the haxe 'haxelib' library tool. This is usually done automatically by the haxe compiler after the cpp code has been generated. It can be done manually like:
```
haxelib run hxcpp build.xml key=value .... [target]
```
### Configuration
The hxcpp build tool is configured using key-value pairs, or just using keys, known internally as 'defines'. These can be set in several ways:
- From system environment variables
- From the command-line, with key=value
- From haxe. Keys defined in haxe with '-D key[=value]' are passed to the build too, where they can influence the build. Certain defines need to be set on the haxe command line so that they can influence the generated code.
- From the the .hxcpp_config.xml file in the users home(profile) directory. This is a good place to set values the apply to the whole machine, like the location of SDKs etc.
- The defines can be manipulated logically from within the build files themselves.
See [Defines.md](Defines.md) for a list of standard defines.
### Format
The compiler specification and target lists all use the same format.
- uses xml parser
- mostly declarative list of files and flags
- order is important
+ overriding values is a valid technique
+ "commands" are run as they are parsed (eg, 'echo')
- conditions via "if" and "unless" node attributes
- substitution via '${VAR}' syntax
- need to define 'default' target
### Conditions/Substitution
Most of the xml nodes support 'if' and 'unless' attributes. These will enable or disable the whole node according the existence or non-existence of a define. These can be combined with a space for "and" or two pipes for "or".
Substitution is supported via the dollars-brace syntax, and does simple text substitution. In addition, there are a few dynamic variables that can be used:
- "${VAR}" - normal replacement
- "${removeQuotes:VAR}" - strips surrounding quotes from VAR, it any
- "${dospath:VAR}" - converts VAR to backwards-slash path
- "${dir:PathWithFilename}" - just the directory part of filename
- "${this_dir}" - the location of the containing build.xml file
### Example
The following code is saved in [example.xml](example.xml) in this directory
```xml
<xml>
<echo value="Hello ${WHO}" if="WHO" unless="SILENT" />
<echo value="You are in ${haxelib:hxcpp}" unless="WHO||SILENT"/>
<error value="Silent and who both specified" if="WHO SILENT"/>
<target id="default" />
</xml>
```
and some example uses:
```
unsetenv SILENT
haxelib run hxcpp example.xml
haxelib run hxcpp example.xml WHO=world default
setenv SILENT 1
haxelib run hxcpp example.xml
haxelib run hxcpp example.xml WHO=world
```
### Details
The build.xml file contains configuration, targets, compilers, linkers and files. The details can be found in this directory.
- [Top Level](TopLevel.md)
- [Files](Files.md)
- [Targets](Targets.md)
- [Compiler](Compiler.md)
- [Linker](Linker.md)
- [Stripper](Stripper.md)
When building from haxe, the "haxe" target is built. You can see the details in [HaxeTarget](HaxeTarget.md).
You can extend the generated Build.xml from haxe code using [Xml injection](XmlInjection.md).

15
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Stripper.md Executable file
View File

@ -0,0 +1,15 @@
Stripper
--------
A stripper is used to remove debug information in release builds on gcc-like systems. It may contain entries:
- *exe* - Override stripper command
```xml
<exe name="command"/>
```
- *flag* - Add flag to stripper command
```xml
<flag value="flag"/>
```

31
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Tags.md Executable file
View File

@ -0,0 +1,31 @@
Tags
----
Tags are identifiers that link compiler flags with specific files. Usually, they are defined in a files group with the 'tags' attribute as a comma separated list, and with the 'tag' attribute on a compiler 'flag' node. Files are then compiled with all the flags that have matching tags.
By restricting tags to certain files, only a sub-set of files needs to be recompiled when conditions change, and files without the relevant tags can reuse their object files. This can save a lot of time, since some flags only apply to a few files.
Files can override the group tags by specifying their own 'tags' attribute. Groups can add tags with the 'tag' node.
Some tags have standard meanings when compiling haxe code:
- *haxe* - The haxe tag adds all the required compiler flags to get haxe-generated code to compile correctly, and should be added to files that depend directly or indirectly on hxcpp.h.
- *static* - This will add the STATIC_LINK define when appropriate, which is used for generating cffi glue. It should be added to cffi code that might generate static libraries.
- *gc* - These flags only affect the garbage-collection files
- *hxstring* - These flags only affect String.cpp
- *optimization tags* - each file is assumed to have exactly 1 optimization tags. If none is explicitly specified, then the default is used depending on whether it is a debug or release build. They are:
+ optim-std = alias for 'debug' or 'release' depending on build
+ debug
+ release
+ optim-none
+ optim-size
Setting one of these tags is useful for compiling your library in release mode, even if haxe has -debug. Some very big files are slow to compile in release mode, so using a less optimized mode can be faster.
The tags attribute can be added to a haxe-generated file using the `@:fileXml` meta, eg:
```haxe
@:fileXml("tags='haxe,optim-none'")
class MyClass { ...
```
Here, the class is compiled with the normal haxe flags, but has the optimizations disabled, which can lead to much faster compiler times in some circumstances.

82
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/Targets.md Executable file
View File

@ -0,0 +1,82 @@
Targets
-------
Targets are used to produce binaries, or to group other targets. When compiling exes or dynamic libraries, they provide the additional link libraries.
By default, hxcpp will try to compile the 'default' target, so it is easiest to define this one - perhaps by simply adding a dependence on your other targets(s).
The target is defined with a 'toolid' attribute; exe, static_link or dll. This defines which linker is run, but many of the target entries will be the same even if the linker is changed.
Targets can contain the following nodes:
- *subTargetName* - Build another target before building this one.
```xml
<target id="subTargetName" />
```
- *merge* - Combine fields from another target. This is useful if you want a target to function as static library or dll when compiled in its own, but also allow it to be used as a list of object files if another target wants to link in the object files directly.
```xml
<merge id="otherTargetName" />
```
- *files* - Add a named group of compiled files to target.
```xml
<files id="filesId"/>
```
- *section* - Group items - usually sharing common condition
```xml
<section > </section>
```
- *lib* - Add a library to the link line.
```xml
<lib (name|hxbase|base)="libName" />
```
+ name = the complete name is specified
+ base = the name without compiler-specific extension (.a/.lib) is specified
+ hxbase = the name without extension and architecture (-v7/.iphoinesim) is specified
- *flag* - Add a single link flag.
```xml
<flag value="flag"/>
```
- *vflag* - Add a pair of link flags.
```xml
<vflag name="flag1" value="flag2"/>
```
- *depend* - Target depends on given filename.
```xml
<depend name="filename"/>
```
- *dir* - Add a directory to the targets directory list. These directories will get removed then the target is cleaned.
```xml
<dir name="tempPath"/>
```
- *outdir* - Directory for build results - including "copyFile" targets
```xml
<outdir name="path"/>
```
- *ext* - Extension for generated files.
```xml
<ext name=".ext"/>
```
+ ext = extension - should contain "."
- *builddir* - The directory from which the targets build commands are run, and therefore the
relative base for some filenames, and destination for some compiler generated temps.
```xml
<builddir name="path"/>
```
- *libpath* Add library search path to build command
```xml
<libpath name="directory"/>
```
+ name = directory. The particular linker will add the required flags

139
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/TopLevel.md Executable file
View File

@ -0,0 +1,139 @@
Structure of the top-level
---------------------------
The top-level nodes live inside an "xml" node, and can be:
- *set* - Set a "define", define being a general variable.
```xml
<set name="name" value="1" />
```
- *setenv* - Sets an hxcpp define and an environment variable for child processes.
```xml
<setenv name="name" value="1" />
```
- *unset* - Unset a define. if="name" will no longer be true
```xml
<unset name="name" />
```
- *setup* - Used internally to call custom setup code to find SDKs etc.
```xml
<setup name="androidNdk|blackberry|msvc|pdbserver|mingw|emscripten|nvcc" />
```
- *echo* - Print value to console. Good for debugging.
```xml
<echo value="text" />
```
- *error* - Print value to console and force error. Good for checking prerequisites.
```xml
<error value="error message" />
```
- *pleaseUpdateHxcppTool* - Used to tell people updating git version that they need to recompile the build tool.
```xml
<pleaseUpdateHxcppTool version="1" />
```
- *path* - Add an directory to the exe search path.
```xml
<path name="directory_to_add" />
```
- *mkdir* - Create a directory.
```xml
<mkdir name="directory" />
```
- *section* - Groups block of elements - usually ones that all respect the same if/unless condition.
```xml
<section name="id" /> </section>
```
- *copy* - Copy file when node is parsed.
```xml
<copy to="destination" from="src" />
```
- *import*/*include* - Read xml from another file. 'import' resets the relative base to the new file, include does not.
```xml
<import name="filename" section="filter" noerror="true" />
<include name="filename" section="filter" noerror="true" />
```
+ noerror - setting the optional noerror allows the file to be missing
+ section - setting the optional section will only read the named section from the xml file. Used by hxcpp_config.xml.
- *pragma* - Only include build file once, even with multiple include statements.
```xml
<pragma once="true" />
```
- *nvccflag* - Add flag to all nvcc compiles.
```xml
<nvccflag name="?name" value="-IincludePath" />
```
- *nvcclinkflag* - Add flag when linking with nvcc code.
```xml
<nvcclinkflag name="?name" value="-arch=sm_30" />
```
- *files* - Define a file group, and set default tags.
```xml
<files dir="dir" name="name" tags="tag1,tag2,tag3" >
...
</files>
```
+ dir = directory to which the filenames in the group are relative
+ tags = comma separated list of flags tags
- *target* - Define a target, and set its toolid(link mode) and output name.
```xml
<target name="name" overwrite="true" append="true" tool="linker" toolid="${haxelink}" output="filename" >
...
</target>
```
- *copyFile* - Copy a file after given toolId is run into target output directory
```xml
<copyFile name="destination" from="src" allowMissing="true" overwrite="true" toolId="filter" >
```
- *magiclib* - Internal for replacing dlls with object files
```xml
<magiclib name="libname" replace="old dll" />
```
- *compiler* - Define a compiler.
```xml
<compiler id="id" exe="command" replace="true" >
...
</compiler>
```
+ Use optional 'replace' to overwrite, otherwise append
+ It is assumed only 1 compiler is active
+ exe can be overridden in the body of the definition
- *stripper* - Define a stripper, to remove debug information for release from gcc executables
```xml
<stripper exe="command" replace="true" > </stripper>
```
+ Use optional 'replace' to overwrite, otherwise append
- *linker* - Define a linker.
```xml
<linker id="id" exe="command" replace="true" > </linker>
```
+ Use optional 'replace' to overwrite, otherwise append
+ id could be 'static_link', 'dll' or 'exe'. Usually all 3 linkers are defined.
+ exe can be overridden in the body of the definition
- *prelinker* - Define a prelinker.
```xml
<prelinker name="id" replace="true" />
...
</prelinker>
```

23
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/XmlInjection.md Executable file
View File

@ -0,0 +1,23 @@
Xml Injection
-------------
When using external code in hxcpp, it is often useful to add libraries, include paths or compiler flags to the build process. This can be done with the `@:buildXml` class meta-data. eg,
```haxe
@:buildXml("
<target id='haxe'>
<lib name='${haxelib:nme}/lib/${BINDIR}/libnme${LIBEXTRA}${LIBEXT}'/>
</target>
")
@:keep
class StaticNme
{
...
```
So, by referencing a given class (you just 'import' the class, no need to use it because it has the @:keep meta-data), the xml fragment is also included.
Here, the xml fragment is copied verbatim into the generated Build.xml immediately after the standard file lists. This example adds a library to the haxe target, but you could also add flags to files nodes, or files to another files node or target. Another possibility is to add an include command to pull in a whole external xml file. This can help avoid some syntax awkwardness needed when quoting strings in meta-data, and allows a normal xml editor to be used.
It is also possible to replace the `__main__` file group to skip the standard initialization code and use a custom bootstrap procedure.

6
Kha/Backends/Kinc-hxcpp/khacpp/docs/build_xml/example.xml Executable file
View File

@ -0,0 +1,6 @@
<xml>
<echo value="Hello ${WHO}" if="WHO" unless="SILENT" />
<echo value="You are in ${haxelib:hxcpp}" unless="WHO||SILENT"/>
<error value="Silent and who both specified" if="WHO SILENT"/>
<target id="default" />
</xml>

14
Kha/Backends/Kinc-hxcpp/khacpp/haxelib.json Normal file
View File

@ -0,0 +1,14 @@
{
"name": "hxcpp",
"url": "https://github.com/HaxeFoundation/hxcpp/",
"license": "BSD",
"tags": ["haxe", "hxcpp", "cpp"],
"description": "Hxcpp is the runtime support for the C++ backend of the Haxe compiler. This contains the headers, libraries and support code required to generate a fully compiled executable from Haxe code.",
"version": "4.3.0",
"releasenote": "See Changes.md",
"contributors": ["gamehaxe", "HaxeFoundation"],
"binaryversion": 48,
"dependencies": {
}
}

5
Kha/Backends/Kinc-hxcpp/khacpp/haxelib.xml Normal file
View File

@ -0,0 +1,5 @@
<project name="hxcpp" url="http://gamehaxe.com/" license="BSD">
<user name="gamehaxe"/>
<description>Hxcpp is the runtime support for the c++ backend of the haxe compiler. This release constains the headers, libraries and support code required to generate a fully compiled executable from haxe code.</description>
<version name="3.1.0">See Changes.txt</version>
</project>

343
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/Builder.hx Normal file
View File

@ -0,0 +1,343 @@
package hxcpp;
import haxe.io.Path;
import sys.FileSystem;
class Builder
{
public var debug:Bool;
public var verbose:Bool;
public function new(inArgs:Array<String>)
{
debug = false;
verbose = false;
var targets = new Map<String, Array<String>>();
var buildArgs = new Array<String>();
try
{
var clean = false;
var defaultTarget = true;
for(arg in inArgs)
{
if (arg=="-debug")
{
debug = true;
continue;
}
else if (arg=="-v" || arg=="-verbose")
{
verbose = true;
Sys.putEnv("HXCPP_VERBOSE", "1");
continue;
}
if (arg=="clean")
{
clean = true;
continue;
}
var parts = arg.split("-");
var linkStatic = allowStatic();
var linkNdll = allowNdll();
var explicitNdll = false;
if (parts[0]=="static")
{
linkNdll = false;
parts.shift();
}
else if (parts[0]=="ndll")
{
linkStatic = false;
explicitNdll = true;
parts.shift();
}
var target = parts.shift();
if (target=="default")
target = getDefault();
switch(target)
{
case "ios", "android", "blackberry", "tizen", "emscripten", "webos", "windows", "msvc", "linux", "mac", "mingw", "tvos":
defaultTarget = false;
if (linkStatic)
{
var stat = "static-" + target;
targets.set(stat, parts);
if (target=="ios" && wantLegacyIosBuild())
{
var stat = "static-" + "ioslegacy";
targets.set(stat, parts);
}
}
if (linkNdll && target!="ios" && target!="emscripten" && target!="tvos" /*&& (target!="mingw" || explicitNdll)*/ )
targets.set(target, parts);
default:
if (arg.substr(0,2)=="-D")
buildArgs.push(arg);
else
throw "Unknown arg '" + arg + "'";
}
}
if (clean)
{
if (!cleanAll(buildArgs))
return;
if (defaultTarget) // Just clean
return;
}
if (defaultTarget)
{
var target = getDefault();
if (target!="mingw")
targets.set(target,[]);
targets.set("static-" +target,[]);
onEmptyTarget();
Sys.println("\nUsing default = " + target);
}
for(target in targets.keys())
{
var archs = targets.get(target);
var validArchs = new Map<String, Array<String>>();
var isStatic = false;
if (target.substr(0,7)=="static-")
{
isStatic = true;
target = target.substr(7);
}
var staticFlags = isStatic ? ["-Dstatic_link"] : [];
if (target=="ios" || target=="tvos")
staticFlags = ["-DHXCPP_CPP11"];
switch(target)
{
case "linux":
if (wantLinux32())
validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
case "mac":
if (wantMac32())
validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
case "windows":
validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"].concat(staticFlags) );
if (wantWindows64())
validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"].concat(staticFlags) );
if (wantWindowsArm64())
validArchs.set("arm64", ["-D"+target, "-DHXCPP_ARM64"].concat(staticFlags) );
case "msvc":
if (isStatic)
{
validArchs.set("2013m32", ["-D"+target, "-DHXCPP_M32", "HXCPP_MSVC_VER=120"].concat(staticFlags) );
validArchs.set("2015m32", ["-D"+target, "-DHXCPP_M32", "HXCPP_MSVC_VER=140"].concat(staticFlags) );
if (wantWindows64())
{
validArchs.set("2013m64", ["-D"+target, "-DHXCPP_M64", "HXCPP_MSVC_VER=120"].concat(staticFlags) );
validArchs.set("2015m64", ["-D"+target, "-DHXCPP_M64", "HXCPP_MSVC_VER=140"].concat(staticFlags) );
}
}
else
{
validArchs.set("m32", ["-D"+target, "-DHXCPP_M32"] );
if (wantWindows64())
validArchs.set("m64", ["-D"+target, "-DHXCPP_M64"] );
}
case "mingw":
validArchs.set("m32", ["-Dwindows", "-DHXCPP_MINGW", "-DHXCPP_M32"].concat(staticFlags) );
case "ios", "ioslegacy":
validArchs.set("armv6", ["-Diphoneos"].concat(staticFlags) );
validArchs.set("armv7", ["-Diphoneos", "-DHXCPP_ARMV7"].concat(staticFlags) );
validArchs.set("armv7s", ["-Diphoneos", "-DHXCPP_ARMV7S"].concat(staticFlags) );
validArchs.set("arm64", ["-Diphoneos", "-DHXCPP_ARM64", "-DHXCPP_M64"].concat(staticFlags) );
//validArchs.push("armv64");
validArchs.set("x86", ["-Diphonesim"].concat(staticFlags) );
validArchs.set("x86_64", ["-Diphonesim", "-DHXCPP_M64"].concat(staticFlags) );
case "android":
if( archs.length == 0 )
throw("You must specify the archs you want for android");
validArchs.set("armv5", ["-Dandroid"].concat(staticFlags) );
validArchs.set("armv7", ["-Dandroid", "-DHXCPP_ARMV7"].concat(staticFlags) );
validArchs.set("arm64", ["-Dandroid", "-DHXCPP_ARM64"].concat(staticFlags) );
validArchs.set("x86", ["-Dandroid", "-DHXCPP_X86"].concat(staticFlags) );
validArchs.set("x86_64", ["-Dandroid", "-DHXCPP_X86_64"].concat(staticFlags) );
case "blackberry":
validArchs.set("armv7", ["-Dblackberry"].concat(staticFlags) );
validArchs.set("x86", ["-Dblackberry", "-Dsimulator"].concat(staticFlags) );
case "tizen":
validArchs.set("armv7", ["-Dtizen"].concat(staticFlags) );
validArchs.set("x86", ["-Dtizen", "-Dsimulator"].concat(staticFlags) );
case "emscripten":
validArchs.set("x86", ["-Demscripten"].concat(staticFlags) );
case "webos":
validArchs.set("armv7", ["-Dwebos"].concat(staticFlags) );
case "tvos":
validArchs.set("arm64", ["-Dappletvos", "-DHXCPP_ARM64", "-DHXCPP_M64", "-DENABLE_BITCODE"].concat(staticFlags) );
// NOTE: removed as there's no 32bit support for the AppleTV simulator
//validArchs.set("x86", ["-Dappletvsim", "-DENABLE_BITCODE"].concat(staticFlags) );
validArchs.set("x86_64", ["-Dappletvsim", "-DHXCPP_M64", "-DENABLE_BITCODE"].concat(staticFlags) );
}
var valid = new Array<String>();
for(key in validArchs.keys())
valid.push(key);
var buildArchs = archs.length==0 ? valid : archs;
for(arch in buildArchs)
{
if (validArchs.exists(arch))
{
var flags = validArchs.get(arch);
if (debug)
flags.push("-Ddebug");
flags = flags.concat(buildArgs);
runBuild(target, isStatic, arch, flags);
}
}
}
}
catch( e:Dynamic )
{
if (e!="")
Sys.println(e);
showUsage(false);
}
}
public function allowNdll() { return true; }
public function allowStatic() { return true; }
public function wantLegacyIosBuild() { return false; }
public function wantWindows64() { return false; }
public function wantMac32() { return false; }
public function wantLinux32() { return false; }
public function wantWindowsArm64() { return false; }
public function runBuild(target:String, isStatic:Bool, arch:String, buildFlags:Array<String>)
{
var args = ["run", "hxcpp", getBuildFile() ].concat(buildFlags);
Sys.println('\nBuild $target, link=' + (isStatic?"lib":"ndll")+' arch=$arch');
Sys.println("haxelib " + args.join(" "));
if (Sys.command("haxelib",args)!=0)
{
Sys.println("#### Error building " + arch);
Sys.exit(-1);
}
}
public function getBuildFile()
{
return "Build.xml";
}
public function getCleanDir()
{
return "obj";
}
public function cleanAll(inBuildFlags:Array<String>) : Bool
{
var args = ["run", "hxcpp", getBuildFile(), "clean", "-DHXCPP_CLEAN_ONLY"].concat(inBuildFlags);
Sys.println("haxelib " + args.join(" "));
if (Sys.command("haxelib",args)!=0)
{
Sys.println("#### Error cleaning");
Sys.exit(-1);
}
return true;
}
public function onEmptyTarget() : Void
{
showUsage(true);
}
static public function deleteRecurse(inDir:String) : Void
{
if (FileSystem.exists(inDir))
{
var contents = FileSystem.readDirectory(inDir);
for(item in contents)
{
if (item!="." && item!="..")
{
var name = inDir + "/" + item;
if (FileSystem.isDirectory(name))
deleteRecurse(name);
else
FileSystem.deleteFile(name);
}
}
FileSystem.deleteDirectory(inDir);
}
}
public function showUsage(inShowSpecifyMessage:Bool) : Void
{
var link = allowStatic() && allowNdll() ? "[link-]" : "";
Sys.println("Usage : neko build.n [clean] " + link +
"target[-arch][-arch] ...] [-debug] [-verbose] [-D...]");
Sys.println(" target : ios, android, windows, linux, mac, mingw, tvos");
Sys.println(" default (=current system)");
if (link!="")
{
Sys.println(" link : ndll- or static-");
Sys.println(" (none specified = both link types, mingw static only");
}
Sys.println(" arch : -armv5 -armv6 -armv7 -arm64 -x86 -x86_64 -m32 -m64");
Sys.println(" (none specified = all valid architectures");
Sys.println(" -D... : defines passed to hxcpp build system");
if (link!="")
Sys.println(" eg: neko build.n clean ndll-mac-m32-m64 = rebuild both mac ndlls");
if (inShowSpecifyMessage)
Sys.println(" Specify target or 'default' to remove this message");
}
public function getDefault() : String
{
var sys = Sys.systemName();
if (new EReg("window", "i").match(sys))
return "windows";
else if (new EReg("linux", "i").match(sys))
return "linux";
else if (new EReg("mac", "i").match(sys))
return "mac";
else
throw "Unknown host system: " + sys;
return "";
}
public static function main()
{
new Builder( Sys.args() );
}
}

21
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/NekoInit.hx Normal file
View File

@ -0,0 +1,21 @@
package hxcpp;
class NekoInit
{
public static function nekoInit(inModuleName:String) : Bool
{
var init = neko.Lib.load(inModuleName, "neko_init", 5);
if (init != null)
{
init( function(s) return new String(s),
function(len:Int) { var r = []; if (len > 0) r[len - 1] = null; return r; },
null,
true,
false);
return true;
}
return false;
}
}

24
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticMysql.hx Normal file
View File

@ -0,0 +1,24 @@
package hxcpp;
#if (hxcpp_api_level>=330)
class StaticMysql { }
#else
@:cppFileCode( 'extern "C" int mysql_register_prims();')
@:buildXml("
<target id='haxe'>
<lib name='${HXCPP}/lib/${BINDIR}/libmysql5${LIBEXTRA}${LIBEXT}'/>
<lib name='ws2_32.lib' if='windows'/>
</target>
")
@:keep class StaticMysql
{
static function __init__()
{
untyped __cpp__("mysql_register_prims();");
}
}
#end

23
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticRegexp.hx Normal file
View File

@ -0,0 +1,23 @@
package hxcpp;
#if (hxcpp_api_level>=330)
class StaticRegexp { }
#else
@:cppFileCode( 'extern "C" int regexp_register_prims();')
@:buildXml("
<target id='haxe'>
<lib name='${HXCPP}/lib/${BINDIR}/libregexp${LIBEXTRA}${LIBEXT}'/>
</target>
")
@:keep class StaticRegexp
{
static function __init__()
{
untyped __cpp__("regexp_register_prims();");
}
}
#end

24
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticSqlite.hx Normal file
View File

@ -0,0 +1,24 @@
package hxcpp;
#if (hxcpp_api_level>=330)
class StaticSqlite { }
#else
@:cppFileCode( 'extern "C" int sqlite_register_prims();')
@:buildXml("
<target id='haxe'>
<lib name='${HXCPP}/lib/${BINDIR}/libsqlite${LIBEXTRA}${LIBEXT}'/>
<lib name='-lpthread' if='linux'/>
</target>
")
@:keep class StaticSqlite
{
static function __init__()
{
untyped __cpp__("sqlite_register_prims();");
}
}
#end

25
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticStd.hx Normal file
View File

@ -0,0 +1,25 @@
package hxcpp;
#if (hxcpp_api_level>=330)
class StaticStd { }
#else
@:cppFileCode( 'extern "C" int std_register_prims();')
@:buildXml("
<target id='haxe'>
<lib name='${HXCPP}/lib/${BINDIR}/libstd${LIBEXTRA}${LIBEXT}'/>
<lib name='ws2_32.lib' if='windows' unless='static_link' />
</target>
")
@:keep class StaticStd
{
static function __init__()
{
untyped __cpp__("std_register_prims();");
}
}
#end

29
Kha/Backends/Kinc-hxcpp/khacpp/hxcpp/StaticZlib.hx Normal file
View File

@ -0,0 +1,29 @@
package hxcpp;
#if (hxcpp_api_level>=330)
class StaticZlib { }
#else
@:cppFileCode( 'extern "C" int zlib_register_prims();')
#if HXCPP_LINK_NO_ZLIB
@:buildXml("
<import name='${HXCPP}/project/libs/zlib/Build.xml'/>
")
#else
@:buildXml("
<target id='haxe'>
<lib name='${HXCPP}/lib/${BINDIR}/libzlib${LIBEXTRA}${LIBEXT}'/>
</target>
")
#end
@:keep class StaticZlib
{
static function __init__()
{
untyped __cpp__("zlib_register_prims();");
}
}
#end

1292
Kha/Backends/Kinc-hxcpp/khacpp/include/Array.h Normal file
View File

File diff suppressed because it is too large Load Diff

498
Kha/Backends/Kinc-hxcpp/khacpp/include/Dynamic.h Normal file
View File

@ -0,0 +1,498 @@
#ifndef HX_DYNAMIC_H
#define HX_DYNAMIC_H
// --- Dynamic ---------------------------------------------------------------
//
// The Dynamic class views all classes through the hx::Object interface, and
// provides generic access to its pointer.
// It uses dynamic_cast to provide strongly-typed access to the real class.
namespace hx { class Interface; }
class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
{
typedef hx::ObjectPtr<hx::Object> super;
public:
Dynamic() {};
Dynamic(int inVal);
Dynamic(short inVal);
Dynamic(unsigned int inVal);
Dynamic(unsigned short inVal);
Dynamic(unsigned char inVal);
Dynamic(signed char inVal);
Dynamic(const cpp::CppInt32__ &inVal);
Dynamic(bool inVal);
Dynamic(double inVal);
Dynamic(float inVal);
Dynamic(cpp::Int64 inVal);
Dynamic(cpp::UInt64 inVal);
Dynamic(hx::Object *inObj) : super(inObj) { }
Dynamic(const String &inString);
Dynamic(const null &inNull) : super(0) { }
Dynamic(const Dynamic &inRHS) : super(inRHS.mPtr) { }
explicit Dynamic(const HX_CHAR *inStr);
Dynamic(const cpp::Variant &inRHS) : super(inRHS.asDynamic()) { }
template<typename T>
Dynamic(const hx::Native<T *> &inInterface):super(inInterface.ptr ? inInterface->__GetRealObject() : (hx::Object *)0 ) { }
#if !defined(__GNUC__) || (defined(__WORDSIZE) && (__WORDSIZE != 64))
Dynamic(long inVal);
Dynamic(unsigned long inVal);
#endif
#ifdef __OBJC__
#ifdef HXCPP_OBJC
Dynamic(const id inObjc);
#endif
#endif
template<typename T,typename S>
explicit Dynamic(const cpp::Struct<T,S> &inRHS) { *this = inRHS; }
template<typename T>
explicit Dynamic(const cpp::Pointer<T> &inRHS) { *this = inRHS; }
void Set(bool inVal);
void Set(int inVal);
void Set(double inVal);
void Set(float inVal);
template<typename RESULT> RESULT StaticCast() const;
inline operator double () const { return mPtr ? mPtr->__ToDouble() : 0.0; }
inline operator float () const { return mPtr ? (float)mPtr->__ToDouble() : 0.0f; }
inline operator int () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator unsigned int () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator short () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator unsigned short () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator unsigned char () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator char () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator signed char () const { return mPtr ? mPtr->__ToInt() : 0; }
inline operator bool() const { return mPtr && mPtr->__ToInt(); }
inline operator cpp::Int64() const { return mPtr ? mPtr->__ToInt64() : 0; }
inline operator cpp::UInt64() const { return mPtr ? mPtr->__ToInt64() : 0; }
// Conversion to generic pointer requires you to tag the class with a typedef
template<typename T>
inline operator typename hx::Native<T *> () const {
return hx::Native<T *>(dynamic_cast<T *>(mPtr));
}
//inline operator cpp::Variant() const { return cpp::Variant(mPtr); }
#ifdef __OBJC__
#ifdef HXCPP_OBJC
#ifdef OBJC_ARC
inline operator id() const { return mPtr ? (__bridge id)mPtr->__GetHandle() : 0; }
#else
inline operator id() const { return mPtr ? (id)mPtr->__GetHandle() : 0; }
#endif
#endif
#endif
inline bool operator !() const { return !mPtr || !mPtr->__ToInt(); }
hx::IndexRef operator[](int inIndex);
inline Dynamic __get(int inIndex) const { return mPtr->__GetItem(inIndex); }
template<typename SOURCE_>
Dynamic(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
hx::ObjectPtr<hx::Object>(inObjectPtr.mPtr) { }
Dynamic Default(const Dynamic &inDef) { return mPtr ? *this : inDef; }
template<typename RETURN_>
RETURN_ Cast() const { return RETURN_(*this); }
template<typename CLASS_>
bool IsClass() { return CLASS_(mPtr,false).mPtr; }
static void __boot();
inline bool IsNumeric() const
{
if (!mPtr) return false;
int t = mPtr->__GetType();
return t==vtInt || t==vtFloat;
}
inline bool IsBool() const
{
if (!mPtr) return false;
int t = mPtr->__GetType();
return t==vtBool;
}
int Compare(const Dynamic &inRHS) const
{
if (mPtr==0) return inRHS.mPtr==0 ? 0 : -1;
if (inRHS.mPtr==0) return -1;
#if (HXCPP_API_LEVEL>=331)
return mPtr->__Compare(inRHS.mPtr);
#else
return mPtr->__Compare(inRHS.mPtr->__GetRealObject());
#endif
}
bool operator==(const null &inRHS) const { return mPtr==0; }
bool operator!=(const null &inRHS) const { return mPtr!=0; }
bool operator == (const Dynamic &inRHS) const
{
// Comparing pointers fails in the case on Nan==Nan
//if (mPtr==inRHS.mPtr) return true;
if (!mPtr && !inRHS.mPtr) return true;
if (!mPtr || !inRHS.mPtr) return false;
#if (HXCPP_API_LEVEL>=331)
return mPtr->__Compare(inRHS.mPtr)==0;
#else
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())==0;
#endif
}
bool operator != (const Dynamic &inRHS) const
{
// Comparing pointers fails in the case on Nan==Nan
//if (mPtr==inRHS.mPtr) return true;
if (!mPtr && !inRHS.mPtr) return false;
if (!mPtr || !inRHS.mPtr) return true;
#if (HXCPP_API_LEVEL>=331)
return mPtr->__Compare(inRHS.mPtr)!=0;
#else
return mPtr->__Compare(inRHS.mPtr->__GetRealObject())!=0;
#endif
}
bool operator == (const cpp::Variant &inRHS) const { return (*this) == Dynamic(inRHS); }
bool operator != (const cpp::Variant &inRHS) const { return (*this) != Dynamic(inRHS); }
#define DYNAMIC_COMPARE_OP( op ) \
bool operator op (const String &inRHS) const { return mPtr && ((String)(*this) op inRHS); } \
bool operator op (double inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
bool operator op (cpp::Int64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
bool operator op (cpp::UInt64 inRHS) const { return IsNumeric() && ((cpp::Int64)(*this) op inRHS); } \
bool operator op (float inRHS) const { return IsNumeric() && ((double)(*this) op inRHS); } \
bool operator op (int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (unsigned int inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (unsigned short inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (signed char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (unsigned char inRHS) const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
bool operator op (bool inRHS) const { return IsBool() && ((double)(*this) op (double)inRHS); } \
bool operator != (const String &inRHS) const { return !mPtr || ((String)(*this) != inRHS); }
bool operator != (double inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
bool operator != (cpp::Int64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
bool operator != (cpp::UInt64 inRHS) const { return !IsNumeric() || ((cpp::Int64)(*this) != inRHS); }
bool operator != (float inRHS) const { return !IsNumeric() || ((double)(*this) != inRHS); }
bool operator != (int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (unsigned int inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (unsigned short inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (signed char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (unsigned char inRHS) const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
bool operator != (bool inRHS) const { return !IsBool() || ((double)(*this) != (double)inRHS); }
#define DYNAMIC_COMPARE_OP_ALL( op ) \
bool operator op (const Dynamic &inRHS) const { return mPtr && (Compare(inRHS) op 0); } \
bool operator op (const cpp::Variant &inRHS) const { return *this op Dynamic(inRHS); } \
DYNAMIC_COMPARE_OP(op)
DYNAMIC_COMPARE_OP( == )
DYNAMIC_COMPARE_OP_ALL( < )
DYNAMIC_COMPARE_OP_ALL( <= )
DYNAMIC_COMPARE_OP_ALL( >= )
DYNAMIC_COMPARE_OP_ALL( > )
template<typename T_>
bool operator==(const hx::ObjectPtr<T_> &inRHS) const
{
if (mPtr==inRHS.mPtr) return true;
if (!mPtr || !inRHS.mPtr) return false;
#if (HXCPP_API_LEVEL>=331)
return mPtr == inRHS.mPtr;
#else
return mPtr->__GetRealObject() == inRHS.mPtr->__GetRealObject();
#endif
}
template<typename T_>
bool operator!=(const hx::ObjectPtr<T_> &inRHS) const
{
if (mPtr==inRHS.mPtr) return false;
if (!mPtr || !inRHS.mPtr) return true;
#if (HXCPP_API_LEVEL>=331)
return mPtr != inRHS.mPtr;
#else
return mPtr->__GetRealObject() != inRHS.mPtr->__GetRealObject();
#endif
}
// Operator + is different, since it must consider strings too...
Dynamic operator+(const Dynamic &inRHS) const;
inline String operator+(const String &s) const;
Dynamic operator+(const cpp::UInt64 &i) const;
Dynamic operator+(const cpp::Int64 &i) const;
Dynamic operator+(const int &i) const;
Dynamic operator+(const unsigned int &i) const;
Dynamic operator+(const short &i) const;
Dynamic operator+(const unsigned short &i) const;
Dynamic operator+(const signed char &i) const;
Dynamic operator+(const unsigned char &i) const;
Dynamic operator+(const double &d) const;
Dynamic operator+(const float &d) const;
Dynamic operator+(const cpp::Variant &d) const;
double operator%(const Dynamic &inRHS) const;
double operator-() const { return mPtr ? - mPtr->__ToDouble() : 0.0; }
double operator++() { double val = mPtr->__ToDouble() + 1; *this = val; return val; }
double operator++(int) {double val = mPtr->__ToDouble(); *this = val+1; return val; }
double operator--() { double val = mPtr->__ToDouble() - 1; *this = val; return val; }
double operator--(int) {double val = mPtr->__ToDouble(); *this = val-1; return val; }
double operator / (const cpp::Variant &inRHS) const { return (double)(*this) / (double)inRHS; } \
double operator / (const Dynamic &inRHS) const { return (double)(*this) / (double)inRHS; } \
double operator / (const double &inRHS) const { return (double)(*this) / (double)inRHS; } \
double operator / (const float &inRHS) const { return (double)(*this) / (double)inRHS; } \
double operator / (const int &inRHS) const { return (double)(*this) / (double)inRHS; }
#define DYNAMIC_ARITH( op ) \
Dynamic operator op (const cpp::Variant &inRHS) const \
{ return mPtr->__GetType()==vtInt && inRHS.isInt() ? \
Dynamic((int)(*this) op (int)inRHS) : \
Dynamic( (double)(*this) op (double)inRHS); } \
Dynamic operator op (const Dynamic &inRHS) const \
{ return mPtr->__GetType()==vtInt && inRHS.mPtr->__GetType()==vtInt ? \
Dynamic((int)(*this) op (int)inRHS) : \
Dynamic( (double)(*this) op (double)inRHS); } \
double operator op (const double &inRHS) const { return (double)(*this) op (double)inRHS; } \
double operator op (const float &inRHS) const { return (double)(*this) op (double)inRHS; } \
Dynamic operator op (const int &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const unsigned int &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const short &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const unsigned short &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const signed char &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const unsigned char &inRHS) const \
{ return mPtr->__GetType()==vtInt ? Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const cpp::Int64 &inRHS) const \
{ return Dynamic((double)(*this) op inRHS); } \
Dynamic operator op (const cpp::UInt64 &inRHS) const \
{ return Dynamic((double)(*this) op inRHS); } \
DYNAMIC_ARITH( - )
DYNAMIC_ARITH( * )
static void ThrowBadFunctionError();
inline void CheckFPtr() { if (!mPtr) ThrowBadFunctionError(); }
inline ::Dynamic operator()() { CheckFPtr(); return mPtr->__run(); }
inline ::Dynamic operator()(const Dynamic &inArg0) { CheckFPtr(); return mPtr->__run(inArg0); }
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1) { CheckFPtr(); return mPtr->__run(inArg0,inArg1); }
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2); }
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3); }
inline ::Dynamic operator()(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4) { CheckFPtr(); return mPtr->__run(inArg0,inArg1,inArg2,inArg3,inArg4); }
HX_DECLARE_DYNAMIC_FUNCTIONS;
typedef const Dynamic &D;
};
namespace hx
{
inline hx::Object *DynamicPtr(Dynamic inVal) { return inVal.mPtr; }
typedef Dynamic (*MemberFunction0)(hx::Object *inObj);
typedef Dynamic (*MemberFunction1)(hx::Object *inObj,const Dynamic &inArg0);
typedef Dynamic (*MemberFunction2)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1);
typedef Dynamic (*MemberFunction3)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
typedef Dynamic (*MemberFunction4)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
typedef Dynamic (*MemberFunction5)(hx::Object *inObj,const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
typedef Dynamic (*MemberFunctionVar)(hx::Object *inObj,const Array<Dynamic> &inArgs);
typedef Dynamic (*StaticFunction0)();
typedef Dynamic (*StaticFunction1)(const Dynamic &inArg0);
typedef Dynamic (*StaticFunction2)(const Dynamic &inArg0,const Dynamic &inArg1);
typedef Dynamic (*StaticFunction3)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2);
typedef Dynamic (*StaticFunction4)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3);
typedef Dynamic (*StaticFunction5)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4);
typedef Dynamic (*StaticFunction6)(const Dynamic &inArg0,const Dynamic &inArg1,const Dynamic &inArg2,const Dynamic &inArg3,const Dynamic &inArg4,const Dynamic &inArg5);
typedef Dynamic (*StaticFunctionVar)(const Array<Dynamic> &inArgs);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction0(const char *,hx::Object *, MemberFunction0);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction1(const char *,hx::Object *, MemberFunction1);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction2(const char *,hx::Object *, MemberFunction2);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction3(const char *,hx::Object *, MemberFunction3);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction4(const char *,hx::Object *, MemberFunction4);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction5(const char *,hx::Object *, MemberFunction5);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunctionVar(const char *,hx::Object *, MemberFunctionVar,int inN);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction0(const char *,StaticFunction0);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction1(const char *,StaticFunction1);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction2(const char *,StaticFunction2);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction3(const char *,StaticFunction3);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction4(const char *,StaticFunction4);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction5(const char *,StaticFunction5);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction6(const char *,StaticFunction6);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunctionVar(const char *,StaticFunctionVar,int inN);
}
template<>
inline int Dynamic::Cast<int>() const { return mPtr ? mPtr->__ToInt() : 0; }
template<>
inline bool Dynamic::Cast<bool>() const { return mPtr ? mPtr->__ToInt() : 0; }
template<>
inline double Dynamic::Cast<double>() const { return mPtr ? mPtr->__ToDouble() : 0; }
template<>
inline float Dynamic::Cast<float>() const { return mPtr ? mPtr->__ToDouble() : 0; }
template<>
inline String Dynamic::Cast<String>() const { return mPtr ? mPtr->toString() : String(null()); }
//
// Gets the class definition that relates to a specific type.
// Most classes have their own class data, by the standard types (non-classes)
// use the template traits to get the class
namespace hx
{
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetIntClass();
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetFloatClass();
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetBoolClass();
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetVoidClass();
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetStringClass();
HXCPP_EXTERN_CLASS_ATTRIBUTES hx::Class &GetInt64Class();
}
template<>
inline bool Dynamic::IsClass<int>() { return mPtr && mPtr->__GetClass()==hx::GetIntClass(); }
template<>
inline bool Dynamic::IsClass<double>() { return mPtr &&
( mPtr->__GetClass()==hx::GetIntClass() || mPtr->__GetClass()==hx::GetFloatClass()) ; }
template<>
inline bool Dynamic::IsClass<float>() { return mPtr && mPtr->__GetClass()==hx::GetFloatClass(); }
template<>
inline bool Dynamic::IsClass<bool>() { return mPtr && mPtr->__GetClass()==hx::GetBoolClass(); }
template<>
inline bool Dynamic::IsClass<null>() { return !mPtr; }
template<>
inline bool Dynamic::IsClass<String>() { return mPtr && mPtr->__GetClass()==hx::GetStringClass(); }
template<>
inline bool Dynamic::IsClass<Dynamic>() { return true; }
template<>
inline bool Dynamic::IsClass< ::cpp::Int64>() { return mPtr && mPtr->__GetClass()==hx::GetInt64Class(); }
inline String Dynamic::operator+(const String &s) const { return Cast<String>() + s; }
#define HX_DYNAMIC_OP_ISEQ(T) \
inline bool operator == (const T &inLHS,const Dynamic &inRHS) { return inRHS==inLHS; } \
inline bool operator != (const T &inLHS,const Dynamic &inRHS) { return inRHS!=inLHS; }
HX_DYNAMIC_OP_ISEQ(String)
HX_DYNAMIC_OP_ISEQ(double)
HX_DYNAMIC_OP_ISEQ(float)
HX_DYNAMIC_OP_ISEQ(int)
HX_DYNAMIC_OP_ISEQ(bool)
inline bool operator < (bool inLHS,const Dynamic &inRHS) { return false; }
inline bool operator <= (bool inLHS,const Dynamic &inRHS) { return false; }
inline bool operator >= (bool inLHS,const Dynamic &inRHS) { return false; }
inline bool operator > (bool inLHS,const Dynamic &inRHS) { return false; }
#if defined(HX_WINRT) && defined(__cplusplus_winrt)
// Try to avoid the compiler using injected Box::operator int and Dynamic(null) when doing ==
template<typename T>
bool operator==(Platform::Box<T> ^inPtr, nullptr_t)
{
void* ptr = (void*) reinterpret_cast<void*>(inPtr);
return ptr==nullptr;
}
#endif
#define COMPARE_DYNAMIC_OP( op ) \
inline bool operator op (double inLHS,const ::Dynamic &inRHS) \
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (float inLHS,const ::Dynamic &inRHS) \
{ return inRHS.IsNumeric() && ((double)inLHS op (double)inRHS); } \
inline bool operator op (int inLHS,const ::Dynamic &inRHS) \
{ return inRHS.IsNumeric() && (inLHS op (double)inRHS); }
COMPARE_DYNAMIC_OP( < )
COMPARE_DYNAMIC_OP( <= )
COMPARE_DYNAMIC_OP( >= )
COMPARE_DYNAMIC_OP( > )
#define ARITH_DYNAMIC( op ) \
inline double operator op (const cpp::Int64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::Int64)inRHS;} \
inline double operator op (const cpp::UInt64 &inLHS,const Dynamic &inRHS) { return inLHS op (cpp::UInt64)inRHS;} \
inline double operator op (const double &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
inline double operator op (const float &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS;} \
inline double operator op (const int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned int &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const signed char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
ARITH_DYNAMIC( - )
ARITH_DYNAMIC( + )
ARITH_DYNAMIC( / )
ARITH_DYNAMIC( * )
double operator%(const int &inLHS,const Dynamic &inRHS);
double operator%(const double &inLHS,const Dynamic &inRHS);
double operator%(const float &inLHS,const Dynamic &inRHS);
template<typename T,typename H> String::String(const cpp::Struct<T,H> &inRHS) { *this = (String)inRHS; }
template<typename OBJ> String::String(const hx::ObjectPtr<OBJ> &inRHS) { *this = Dynamic(inRHS); }
#endif

196
Kha/Backends/Kinc-hxcpp/khacpp/include/Enum.h Normal file
View File

@ -0,0 +1,196 @@
#ifndef HX_ENUM_H
#define HX_ENUM_H
// Enum (ie enum object class def) is the same as Class.
typedef hx::Class Enum;
namespace hx
{
// --- hx::EnumBase_obj ----------------------------------------------------------
//
// Base class for Enums.
// Specializations of this class don't actually add more data, just extra constructors
// and type information.
class HXCPP_EXTERN_CLASS_ATTRIBUTES EnumBase_obj : public hx::Object
{
typedef hx::Object super;
typedef EnumBase_obj OBJ_;
protected:
#if (HXCPP_API_LEVEL >= 330)
String _hx_tag;
int mFixedFields;
#ifdef HXCPP_SCRIPTABLE
struct CppiaClassInfo *classInfo;
#endif
#else
String tag;
DynamicArray mArgs;
#endif
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdEnum };
int index;
public:
inline void *operator new( size_t inSize, int inExtra=0)
{
return hx::Object::operator new(inSize+inExtra, true, 0);
}
inline void operator delete(void *, int inExtra ) { }
inline void operator delete(void *, size_t inSize ) { }
inline void operator delete(void *, size_t inSize, int inExtra ) { }
HX_DO_ENUM_RTTI_INTERNAL;
static hx::ObjectPtr<hx::Class_obj> &__SGetClass();
String toString();
EnumBase_obj() : index(-1) { }
EnumBase_obj(const null &inNull) : index(-1) { }
int __GetType() const { return vtEnum; }
static Dynamic __CreateEmpty();
static Dynamic __Create(DynamicArray inArgs);
static void __boot();
void __Mark(hx::MarkContext *__inCtx);
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx);
#endif
static hx::ObjectPtr<EnumBase_obj> Resolve(String inName);
inline static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp) { return false; }
#if (HXCPP_API_LEVEL >= 330)
inline cpp::Variant *_hx_getFixed() { return (cpp::Variant *)(this + 1); }
inline const cpp::Variant *_hx_getFixed() const { return (cpp::Variant *)(this + 1); }
inline ::Dynamic __Param(int inID) { return _hx_getFixed()[inID]; }
template<typename T>
inline EnumBase_obj *_hx_init(int inIndex,const T &inValue)
{
#ifdef HXCPP_GC_GENERATIONAL
cpp::Variant &v = _hx_getFixed()[inIndex];
v = inValue;
if (v.type<=cpp::Variant::typeString)
HX_OBJ_WB_GET(this, v.valObject);
#else
_hx_getFixed()[inIndex] = inValue;
#endif
return this;
}
inline void _hx_setIdentity(const String &inTag, int inIndex,int inFixedFields)
{
_hx_tag = inTag;
HX_OBJ_WB_GET(this, _hx_tag.__s);
index = inIndex;
mFixedFields = inFixedFields;
}
DynamicArray _hx_getParameters();
inline ::Dynamic _hx_getObject(int inId) { return _hx_getFixed()[inId].asDynamic(); }
inline int _hx_getInt(int inId) { return _hx_getFixed()[inId]; }
inline ::cpp::Int64 _hx_getInt64(int inId) { return _hx_getFixed()[inId].asInt64(); }
inline Float _hx_getFloat(int inId) { return _hx_getFixed()[inId]; }
inline bool _hx_getBool(int inId) { return _hx_getFixed()[inId]; }
inline ::String _hx_getString(int inId) { return _hx_getFixed()[inId].asString(); }
inline ::Dynamic _hx_getParamI(int inId) { return _hx_getFixed()[inId]; }
inline int _hx_getParamCount() { return mFixedFields; }
// Alias for _hx_getParamI
Dynamic __GetItem(int inIndex) const;
// For legacy
inline String __Tag() const { return _hx_tag; }
String _hx_getTag() const { return _hx_tag; }
int _hx_getIndex() const { return index; }
#else
Dynamic __Param(int inID) { return mArgs[inID]; }
DynamicArray __EnumParams() { return mArgs; }
String __Tag() const { return tag; }
int __Index() const { return index; }
void __Set( const String &inName,int inIndex,DynamicArray inArgs)
{
tag = inName;
index = inIndex;
mArgs = inArgs;
}
#endif
int __Compare(const hx::Object *inRHS) const;
virtual String GetEnumName( ) const { return HX_CSTRING("Enum"); }
};
typedef hx::ObjectPtr<EnumBase_obj> EnumBase;
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_enum_eq( ::hx::EnumBase a, ::hx::EnumBase b);
// --- CreateEnum -------------------------------------------------------------
//
// Template function to return a strongly-typed version fo the Enum.
// Most of the common stuff is in "Set".
#if (HXCPP_API_LEVEL >= 330)
template<typename ENUM>
ENUM *CreateEnum(const String &inName,int inIndex, int inFields)
{
ENUM *result = new (inFields*sizeof(cpp::Variant)) ENUM;
result->_hx_setIdentity(inName,inIndex,inFields);
return result;
}
template<typename ENUM>
ENUM *CreateConstEnum(const String &inName,int inIndex)
{
ENUM vtable;
ENUM *result = (ENUM *)hx::InternalCreateConstBuffer(&vtable,sizeof(ENUM));
result->_hx_setIdentity(inName,inIndex,0);
return result;
}
#else
template<typename ENUM>
hx::ObjectPtr<ENUM> CreateEnum(const String &inName,int inIndex, DynamicArray inArgs=DynamicArray())
{
ENUM *result = new ENUM;
result->__Set(inName,inIndex,inArgs);
return result;
}
#endif
} // end namespace hx
#if (HXCPP_API_LEVEL >= 330)
inline int _hx_getEnumValueIndex(hx::EnumBase inEnum)
{
return inEnum->_hx_getIndex();
}
#endif
inline void __hxcpp_enum_force(hx::EnumBase inEnum,String inForceName, int inIndex)
{
#if (HXCPP_API_LEVEL >= 330)
inEnum->_hx_setIdentity(inForceName, inIndex,0);
#else
hx::DynamicArray empty;
inEnum->__Set(inForceName, inIndex, empty);
#endif
}
#endif

92
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/CppInt32__.h Normal file
View File

@ -0,0 +1,92 @@
#ifndef INCLUDED_haxe_CppInt32__
#define INCLUDED_haxe_CppInt32__
#include <hxcpp.h>
namespace cpp
{
#define HX_I32_DEF_FUNC1(Name) \
static inline Dynamic __##Name(const Dynamic &a) { return Name(a); } \
static inline Dynamic Name##_dyn() { return hx::CreateStaticFunction1(#Name,&CppInt32__::__##Name); }
#define HX_I32_DEF_FUNC2(Name) \
static inline Dynamic __##Name(const Dynamic &a, const Dynamic &b) { return Name(a,b); } \
static inline Dynamic Name##_dyn() { return hx::CreateStaticFunction2(#Name,&CppInt32__::__##Name); }
class CppInt32__
{
public:
CppInt32__(int inX=0) : mValue(inX) { }
CppInt32__(const null &inNull) : mValue(0) { }
CppInt32__(const Dynamic &inD);
operator int() const { return mValue; }
template<typename T>
inline CppInt32__ &operator=(T inValue) { mValue = inValue; return *this; }
static inline CppInt32__ make(int a,int b) { return CppInt32__( (a<<16) | b ); }
static inline CppInt32__ ofInt(int a) { return CppInt32__( a ); }
static inline int toInt(CppInt32__ a) { __hxcpp_check_overflow(a); return a.mValue; }
static inline int toNativeInt(CppInt32__ a) { return a.mValue; }
static inline CppInt32__ add(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue + b.mValue ); }
static inline CppInt32__ sub(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue - b.mValue ); }
static inline CppInt32__ mul(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue * b.mValue ); }
static inline CppInt32__ div(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue / b.mValue ); }
static inline CppInt32__ mod(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue % b.mValue ); }
static inline CppInt32__ shl(CppInt32__ a,int b) { return CppInt32__( a.mValue << (b&31) ); }
static inline CppInt32__ shr(CppInt32__ a,int b) { return CppInt32__( a.mValue >> (b&31) ); }
static inline CppInt32__ ushr(CppInt32__ a,int b) { return CppInt32__( ((unsigned int)a.mValue) >> (b&31) ); }
static inline CppInt32__ _and(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue & b.mValue ); }
static inline CppInt32__ _or(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue | b.mValue ); }
static inline CppInt32__ _xor(CppInt32__ a,CppInt32__ b) { return CppInt32__( a.mValue ^ b.mValue ); }
static inline CppInt32__ neg(CppInt32__ a) { return CppInt32__( -a.mValue ); }
static inline CppInt32__ complement(CppInt32__ a) { return CppInt32__( ~a.mValue ); }
static inline int compare(CppInt32__ a,CppInt32__ b) { return ( a.mValue - b.mValue ); }
static inline bool isNeg(CppInt32__ a) { return a.mValue < 0; }
static inline bool isZero(CppInt32__ a) { return a.mValue == 0; }
static inline int ucompare(CppInt32__ a,CppInt32__ b) { unsigned int am = a.mValue, bm = b.mValue; return (am == bm) ? 0 : ((am > bm) ? 1 : -1); }
inline bool operator==(const CppInt32__ &inRHS) const { return mValue == inRHS.mValue; }
inline int operator-(CppInt32__ b) { return mValue - b.mValue; }
inline int operator+(CppInt32__ b) { return mValue + b.mValue; }
inline int operator*(CppInt32__ b) { return mValue * b.mValue; }
inline int operator/(CppInt32__ b) { return mValue / b.mValue; }
inline int operator%(CppInt32__ b) { return mValue % b.mValue; }
HX_I32_DEF_FUNC2(make)
HX_I32_DEF_FUNC1(ofInt)
HX_I32_DEF_FUNC1(toInt)
HX_I32_DEF_FUNC1(toNativeInt)
HX_I32_DEF_FUNC2(add)
HX_I32_DEF_FUNC2(sub)
HX_I32_DEF_FUNC2(mul)
HX_I32_DEF_FUNC2(div)
HX_I32_DEF_FUNC2(mod)
HX_I32_DEF_FUNC2(shl)
HX_I32_DEF_FUNC2(shr)
HX_I32_DEF_FUNC2(ushr)
HX_I32_DEF_FUNC2(_and)
HX_I32_DEF_FUNC2(_or)
HX_I32_DEF_FUNC2(_xor)
HX_I32_DEF_FUNC1(neg)
HX_I32_DEF_FUNC1(complement)
HX_I32_DEF_FUNC2(compare)
HX_I32_DEF_FUNC2(ucompare)
HX_I32_DEF_FUNC1(isNeg)
HX_I32_DEF_FUNC1(isZero)
int mValue;
};
typedef CppInt32__ CppInt32___obj;
}
#endif

108
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/FastIterator.h Normal file
View File

@ -0,0 +1,108 @@
#ifndef INCLUDED_cpp_FastIterator
#define INCLUDED_cpp_FastIterator
namespace cpp
{
class HXCPP_EXTERN_CLASS_ATTRIBUTES IteratorBase : public hx::Object
{
public:
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
virtual bool hasNext() = 0;
virtual Dynamic _dynamicNext() = 0;
Dynamic hasNext_dyn( );
Dynamic next_dyn( );
Dynamic _dynamicNext_dyn( );
};
template<typename T>
class HXCPP_EXTERN_CLASS_ATTRIBUTES FastIterator_obj : public IteratorBase
{
public:
virtual bool hasNext() = 0;
virtual T next() = 0;
virtual Dynamic _dynamicNext() { return next(); }
};
template<typename T>
class HXCPP_EXTERN_CLASS_ATTRIBUTES DynamicIterator : public FastIterator_obj<T>
{
public:
Dynamic mNext;
Dynamic mHasNext;
DynamicIterator(Dynamic inValue)
{
mNext = inValue->__Field(HX_CSTRING("next"), HX_PROP_ALWAYS);
mHasNext = inValue->__Field(HX_CSTRING("hasNext"), HX_PROP_ALWAYS);
}
bool hasNext() { return mHasNext(); }
T next() { return mNext(); }
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER_NAME(mNext,"mNext");
HX_MARK_MEMBER_NAME(mHasNext,"mHasNext");
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER_NAME(mNext,"mNext");
HX_VISIT_MEMBER_NAME(mHasNext,"mHasNext");
}
#endif
};
template<typename T>
FastIterator_obj<T> *CreateFastIterator(Dynamic inValue)
{
FastIterator_obj<T> *result = dynamic_cast< FastIterator_obj<T> *>(inValue.GetPtr());
if (result) return result;
return new DynamicIterator<T>(inValue);
}
template<typename T>
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringIterator : public cpp::FastIterator_obj<T>
{
public:
String value;
int pos;
StringIterator(const String &inValue) : value(inValue), pos(0) { }
bool hasNext() { return pos<value.length; }
void __Mark(hx::MarkContext *__inCtx)
{
cpp::FastIterator_obj<T>::__Mark(__inCtx);
HX_MARK_MEMBER_NAME(value,"value");
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
cpp::FastIterator_obj<T>::__Visit(__inCtx);
HX_VISIT_MEMBER_NAME(value,"value");
}
#endif
};
}
#endif

148
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Int64.h Normal file
View File

@ -0,0 +1,148 @@
#ifndef CPP_INT64_INCLUDED
#define CPP_INT64_INCLUDED
namespace cpp
{
class Int64Handler
{
public:
static inline const char *getName() { return "cpp.Int64"; }
static inline String toString( const void *inValue ) { return String( *(Int64 *)inValue ); }
static inline void handler(DynamicHandlerOp op, void *ioValue,int inSize, void *outResult)
{
if (op==dhoToString)
*(String *)outResult = toString(ioValue);
else if (op==dhoGetClassName)
*(const char **)outResult = getName();
else if (op==dhoFromDynamic)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
cpp::Int64 &value = *(cpp::Int64 *)ioValue;
params->outProcessed = true;
if (!params->inData)
value = 0;
else
value = params->inData->__ToInt64();
}
else if (op==dhoToDynamic)
{
Dynamic value = *(cpp::Int64 *)ioValue;
*(hx::Object **)outResult = value.mPtr;
}
else if (op==dhoIs)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
hx::Object *obj = params->inData;
int type = obj->__GetType();
params->outProcessed = type==vtInt || type==vtInt64;
}
else
return DefaultStructHandler::handler(op,ioValue,inSize, outResult);
}
};
typedef Struct<Int64,Int64Handler> Int64Struct;
}
#if (HXCPP_API_LEVEL >= 420)
inline cpp::Int64 _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
{
return a==b ? 0 : a<b ? -1 : 1;
}
inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
{
return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
}
inline String _hx_int64_to_string(cpp::Int64 a) { return a; }
inline cpp::Int64 _hx_int64_neg(cpp::Int64 a) { return -a; }
inline cpp::Int64 _hx_int64_complement(cpp::Int64 a) { return ~a; }
inline cpp::Int64 _hx_int64_pre_increment(cpp::Int64 &ioVal) {
return ++ioVal;
}
inline cpp::Int64 _hx_int64_post_increment(cpp::Int64 &ioVal) {
return ioVal++;
}
inline cpp::Int64 _hx_int64_pre_decrement(cpp::Int64 &ioVal) {
return --ioVal;
}
inline cpp::Int64 _hx_int64_post_decrement(cpp::Int64 &ioVal) {
return ioVal--;
}
inline cpp::Int64 _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
inline cpp::Int64 _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
inline cpp::Int64 _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
inline cpp::Int64 _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
inline cpp::Int64 _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
inline cpp::Int64 _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
inline cpp::Int64 _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
inline cpp::Int64 _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
inline cpp::Int64 _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
inline cpp::Int64 _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
inline cpp::Int64 _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
inline int _hx_int64_high(cpp::Int64 a) { return (int)( a >> 32 ); }
inline int _hx_int64_low(cpp::Int64 a) { return (int)( a & 0xffffffff ); }
#else
inline cpp::Int64Struct _hx_int64_make(int a, int b) { return (((cpp::Int64)(unsigned int)a)<<32) | (unsigned int)b; }
inline bool _hx_int64_is_neg(cpp::Int64 a) { return a<0; }
inline bool _hx_int64_is_zero(cpp::Int64 a) { return a==0; }
inline bool _hx_int64_eq(cpp::Int64 a, cpp::Int64 b) { return a==b; }
inline bool _hx_int64_neq(cpp::Int64 a, cpp::Int64 b) { return a!=b; }
inline int _hx_int64_compare(cpp::Int64 a, cpp::Int64 b)
{
return a==b ? 0 : a<b ? -1 : 1;
}
inline int _hx_int64_ucompare(cpp::Int64 a, cpp::Int64 b)
{
return a==b ? 0 : ( ::cpp::UInt64)a<( ::cpp::UInt64)b ? -1 : 1;
}
inline String _hx_int64_to_string(cpp::Int64Struct a) { return a; }
inline cpp::Int64Struct _hx_int64_neg(cpp::Int64 a) { return -a; }
inline cpp::Int64Struct _hx_int64_complement(cpp::Int64 a) { return ~a; }
inline cpp::Int64Struct _hx_int64_pre_increment(cpp::Int64Struct &ioVal) {
return ++ioVal.get();
}
inline cpp::Int64Struct _hx_int64_post_increment(cpp::Int64Struct &ioVal) {
return ioVal.get()++;
}
inline cpp::Int64Struct _hx_int64_pre_decrement(cpp::Int64Struct &ioVal) {
return --ioVal.get();
}
inline cpp::Int64Struct _hx_int64_post_decrement(cpp::Int64Struct &ioVal) {
return ioVal.get()--;
}
inline cpp::Int64Struct _hx_int64_sub(cpp::Int64 a, cpp::Int64 b) { return a-b; }
inline cpp::Int64Struct _hx_int64_add(cpp::Int64 a, cpp::Int64 b) { return a+b; }
inline cpp::Int64Struct _hx_int64_mul(cpp::Int64 a, cpp::Int64 b) { return a*b; }
inline cpp::Int64Struct _hx_int64_div(cpp::Int64 a, cpp::Int64 b) { return a/b; }
inline cpp::Int64Struct _hx_int64_mod(cpp::Int64 a, cpp::Int64 b) { return a%b; }
inline cpp::Int64Struct _hx_int64_and(cpp::Int64 a, cpp::Int64 b) { return a&b; }
inline cpp::Int64Struct _hx_int64_or(cpp::Int64 a, cpp::Int64 b) { return a|b; }
inline cpp::Int64Struct _hx_int64_xor(cpp::Int64 a, cpp::Int64 b) { return a^b; }
inline cpp::Int64Struct _hx_int64_shl(cpp::Int64 a, int b) { return a<<(b&63); }
inline cpp::Int64Struct _hx_int64_shr(cpp::Int64 a, int b) { return a>>(b&63); }
inline cpp::Int64Struct _hx_int64_ushr(cpp::Int64 a, int b) { return ((cpp::UInt64)a)>>(b&63); }
inline int _hx_int64_high(cpp::Int64Struct a) { return (int)( a.get() >>32 ); }
inline int _hx_int64_low(cpp::Int64Struct a) { return (int)( a.get() & 0xffffffff ); }
#endif
#endif

562
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Pointer.h Normal file
View File

@ -0,0 +1,562 @@
#ifndef CPP_POINTER_H
#define CPP_POINTER_H
namespace cpp
{
struct AutoCast
{
void *value;
explicit inline AutoCast(void *inValue) : value(inValue) { }
};
struct RawAutoCast
{
void *value;
explicit inline RawAutoCast(void *inValue) : value(inValue) { }
template<typename T>
operator T*() const { return (T*)value; }
};
Dynamic CreateDynamicPointer(void *inValue);
enum DynamicHandlerOp
{
dhoGetClassName,
dhoToString,
dhoFromDynamic,
dhoToDynamic,
dhoIs,
};
typedef void (*DynamicHandlerFunc)(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult);
Dynamic CreateDynamicStruct(const void *inValue, int inSize, DynamicHandlerFunc inFunc);
template<typename T> class Reference;
struct StructHandlerDynamicParams
{
StructHandlerDynamicParams(hx::Object *data,const char *inName) :
outProcessed(false), inName(inName), inData(data) { }
bool outProcessed;
hx::Object *inData;
const char *inName;
};
class DefaultStructHandler
{
public:
static inline const char *getName() { return "unknown"; }
static inline String toString( const void *inValue ) { return HX_CSTRING("Struct"); }
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
{
if (op==dhoToString)
*(String *)outResult = toString(ioValue);
else if (op==dhoGetClassName)
*(const char **)outResult = getName();
else if (op==dhoToDynamic)
{
// Handle outsize..
*(hx::Object **)outResult = 0;
}
else if (op==dhoFromDynamic)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
hx::Object *ptr= params->inData;
void *data = (void *)ptr->__GetHandle();
int len = ptr->__length();
if (data && len>=inSize && ptr->__CStr()==params->inName)
{
memcpy(ioValue,data,inSize);
params->outProcessed = true;
}
}
else if (op==dhoIs)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
hx::Object *ptr= params->inData;
void *data = (void *)ptr->__GetHandle();
int len = ptr->__length();
params->outProcessed = data && len>=inSize && ptr->__CStr()==params->inName;
}
}
};
class EnumHandler
{
public:
static inline const char *getName() { return "enum"; }
static inline String toString( const void *inValue ) {
int val = inValue ? *(int *)inValue : 0;
return HX_CSTRING("enum(") + String(val) + HX_CSTRING(")");
}
static inline void handler(DynamicHandlerOp op, void *ioValue, int inSize, void *outResult)
{
if (op==dhoToString)
*(String *)outResult = toString(ioValue);
else if (op==dhoGetClassName)
*(const char **)outResult = getName();
else if (op==dhoFromDynamic)
{
StructHandlerDynamicParams *params = (StructHandlerDynamicParams *)outResult;
if (params->inData->__GetType()==vtInt)
{
*(int *)ioValue = params->inData->__ToInt();
params->outProcessed = true;
}
else
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
}
else
DefaultStructHandler::handler(op,ioValue, inSize, outResult);
}
};
template<typename T, typename HANDLER = DefaultStructHandler >
class Struct
{
public:
T value;
// This allows 'StaticCast' to be used from arrays
typedef Dynamic Ptr;
inline Struct( ) { }
inline Struct( const T &inRHS ) : value(inRHS) { }
inline Struct( const null &) { value = T(); }
inline Struct( const Reference<T> &);
inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }
inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }
operator Dynamic() const
{
hx::Object *result = 0;
HANDLER::handler(dhoToDynamic, (void *)&value, sizeof(T), &result );
if (result)
return result;
return CreateDynamicStruct( &value, sizeof(T), HANDLER::handler);
}
operator String() const { return HANDLER::toString(&value); }
#if (HXCPP_API_LEVEL >= 330)
inline Struct( const hx::Val &inRHS) { fromDynamic(inRHS.asObject()); }
operator hx::Val() const { return operator Dynamic(); }
#endif
bool operator==(const Struct<T,HANDLER> &inRHS) const { return value==inRHS.value; }
bool operator==(const null &inRHS) const { return false; }
bool operator!=(const null &inRHS) const { return true; }
// Haxe uses -> notation
inline T *operator->() { return &value; }
T &get() { return value; }
static inline bool is( const Dynamic &inRHS)
{
hx::Object *ptr = inRHS.mPtr;
if (!ptr)
return false;
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
HANDLER::handler(dhoIs, 0, sizeof(T), &convert );
return convert.outProcessed;
}
inline void fromDynamic( hx::Object *ptr)
{
if (!ptr)
{
value = T();
return;
}
StructHandlerDynamicParams convert(ptr, ptr->__CStr());
HANDLER::handler(dhoFromDynamic, &value, sizeof(T), &convert );
if (!convert.outProcessed)
{
hx::NullReference("DynamicData", true);
return;
}
}
inline operator T& () { return value; }
};
template<typename T>
class Pointer
{
public:
typedef T elementType;
T *ptr;
inline Pointer( ) : ptr(0) { }
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Pointer( const null &inRHS ) : ptr(0) { }
inline Pointer( const cpp::Variant &inVariant ) {
hx::Object *obj = inVariant.asObject();
ptr = obj ? (T*)inVariant.valObject->__GetHandle() : 0;
}
template<typename O>
inline Pointer( const O *inValue ) : ptr( (T*) inValue) { }
//inline Pointer( T *inValue ) : ptr(inValue) { }
inline Pointer( AutoCast inValue ) : ptr( (T*)inValue.value) { }
template<typename H>
inline Pointer( const Struct<T,H> &structVal ) : ptr( &structVal.value ) { }
template<typename O>
inline void setRaw(const O *inValue ) { ptr = (T*) inValue; }
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
inline Dynamic operator=( Dynamic &inValue )
{
ptr = inValue==null() ? 0 : (T*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
template<typename O>
inline Pointer operator=( const Pointer<O> &inValue ) { ptr = (T*) inValue.ptr; return *this; }
template<typename O>
inline Pointer operator=( const O *inValue ) { ptr = (T*) inValue; return *this; }
template<typename H>
inline Pointer operator=( const Struct<T,H> &structVal ) { ptr = &structVal.value; return *this; }
inline AutoCast reinterpret() { return AutoCast(ptr); }
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
inline bool operator==( const null &inValue ) const { return ptr==0; }
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
// Allow '->' syntax
inline Pointer *operator->() { return this; }
inline Pointer inc() { return ++ptr; }
inline Pointer dec() { return --ptr; }
inline Pointer add(int inInt) { return ptr+inInt; }
inline Pointer sub(int inInt) { return ptr-inInt; }
inline Pointer incBy(int inDiff) { ptr+=inDiff; return ptr; }
inline Pointer decBy(int inDiff) { ptr-=inDiff; return ptr; }
inline T &postIncRef() { return *ptr++; }
inline T &postIncVal() { return *ptr++; }
inline T &at(int inIndex) { return ptr[inIndex]; }
inline void setAt(int inIndex, const T &test) { ptr[inIndex] = test; }
inline T &__get(int inIndex) { return ptr[inIndex]; }
inline T &__set(int inIndex, const T &inValue) { T *p = ptr+inIndex; *p = inValue; return *p; }
inline T &get_value() { return *ptr; }
inline T &get_ref() { return *ptr; }
inline T &set_ref(const T &inValue) { return *ptr = inValue; }
operator Dynamic () const { return CreateDynamicPointer((void *)ptr); }
#if (HXCPP_API_LEVEL >= 330)
operator cpp::Variant () const { return CreateDynamicPointer((void *)ptr); }
#endif
operator T * () { return ptr; }
T * get_raw() { return ptr; }
const T * get_constRaw() { return ptr; }
inline void destroy() { delete ptr; }
inline void destroyArray() { delete [] ptr; }
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
};
template<>
class Pointer<void>
{
public:
enum { elementSize = 0 };
void *ptr;
inline Pointer( ) : ptr(0) { }
inline Pointer( const Pointer &inRHS ) : ptr(inRHS.ptr) { }
inline Pointer( const Dynamic &inRHS) { ptr = inRHS==null()?0: (void*)inRHS->__GetHandle(); }
inline Pointer( const null &inRHS ) : ptr(0) { }
template<typename O>
inline Pointer( const O *inValue ) : ptr( (void*) inValue) { }
//inline Pointer( T *inValue ) : ptr(inValue) { }
inline Pointer( AutoCast inValue ) : ptr( (void*)inValue.value) { }
inline Pointer operator=( const Pointer &inRHS ) { return ptr = inRHS.ptr; }
inline Dynamic operator=( Dynamic &inValue )
{
ptr = inValue==null() ? 0 : (void*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { ptr=0; return inValue; }
inline AutoCast reinterpret() { return AutoCast(ptr); }
inline RawAutoCast rawCast() { return RawAutoCast(ptr); }
inline bool operator==( const null &inValue ) const { return ptr==0; }
inline bool operator!=( const null &inValue ) const { return ptr!=0; }
// Allow '->' syntax
inline Pointer *operator->() { return this; }
inline Pointer inc() { return ptr; }
inline Pointer dec() { return ptr; }
inline Pointer add(int inInt) { return ptr; }
inline Pointer sub(int inInt) { return ptr; }
inline Pointer incBy(int inDiff) { return ptr; }
inline Pointer decBy(int inDiff) { return ptr; }
inline void postIncRef() { }
inline void postIncVal() { }
inline void at(int inIndex) { }
inline void __get(int inIndex) { }
template<typename O>
inline void __set(int inIndex, O inValue) { }
inline void get_value() { }
inline void get_ref() { }
template<typename O> inline void set_ref(O val) { }
operator Dynamic () const { return CreateDynamicPointer(ptr); }
//operator hx::Val () const { return CreateDynamicPointer((void *)ptr); }
operator void * () { return ptr; }
void * get_raw() { return ptr; }
const void * get_constRaw() { return ptr; }
inline void destroy() { }
inline void destroyArray() { }
inline bool lt(Pointer inOther) { return ptr < inOther.ptr; }
inline bool gt(Pointer inOther) { return ptr > inOther.ptr; }
inline bool leq(Pointer inOther) { return ptr <= inOther.ptr; }
inline bool geq(Pointer inOther) { return ptr >= inOther.ptr; }
};
template<typename T>
inline bool operator == (const null &, Pointer<T> inPtr) { return inPtr.ptr==0; }
template<typename T>
inline bool operator != (const null &, Pointer<T> inPtr) { return inPtr.ptr!=0; }
template<typename T>
class Reference : public Pointer<T>
{
public:
using Pointer<T>::ptr;
inline Reference( const T &inRHS ) : Pointer<T>(&inRHS) { }
inline Reference( T &inRHS ) : Pointer<T>(&inRHS) { }
inline Reference( ) : Pointer<T>((T*)0) { }
inline Reference( const Reference &inRHS ) : Pointer<T>(inRHS.ptr) { }
inline Reference( const Dynamic &inRHS) { ptr = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Reference( const null &inRHS ) : Pointer<T>((T*)0) { }
inline Reference( const T *inValue ) : Pointer<T>( (T*) inValue) { }
//inline Reference( T *inValue ) : Pointer(inValue) { }
inline Reference( AutoCast inValue ) : Pointer<T>( (T*)inValue.value) { }
template<typename OTHER>
inline Reference( const Reference<OTHER> &inOther )
{
// Allow reinterpret or not?
ptr = (T*)inOther.ptr;
}
template<typename H>
inline Reference( const Struct<T,H> &structVal ) : Pointer<T>( &structVal.value ) { }
inline Reference operator=( const Reference &inRHS ) { return ptr = inRHS.ptr; }
inline T *operator->() const { return ptr; }
inline operator T &() { return *ptr; }
};
template<typename T,typename H>
Struct<T,H>::Struct( const Reference<T> &ref ) : value(*ref.ptr) { };
template<typename T>
class Function
{
public:
T *call;
inline Function( ) { }
inline Function( const Function &inRHS ) : call(inRHS.call) { }
inline Function( const Dynamic &inRHS) { call = inRHS==null()?0: (T*)inRHS->__GetHandle(); }
inline Function( const null &inRHS ) { call = 0; }
inline Function( T *inValue ) : call((T*)(inValue)) { }
//inline Function( T *inValue ) : call(inValue) { }
inline Function( AutoCast inValue ) : call( (T*)inValue.value) { }
inline Function( const hx::AnyCast &inValue ) : call( (T*)inValue.mPtr) { }
template<typename FROM>
inline static Function __new(FROM from)
{
return Function(from);
}
inline Function operator=( const Function &inRHS ) { return call = inRHS.call; }
inline Dynamic operator=( Dynamic &inValue )
{
call = inValue==null() ? 0 : (T*) inValue->__GetHandle();
return inValue;
}
inline Dynamic operator=( null &inValue ) { call=0; return inValue; }
inline bool operator==( const null &inValue ) const { return call==0; }
inline bool operator!=( const null &inValue ) const { return call!=0; }
operator Dynamic () const { return CreateDynamicPointer((void *)call); }
//operator hx::Val () const { return CreateDynamicPointer((void *)call); }
operator T * () { return call; }
operator void * () { return (void *)call; }
inline T &get_call() { return *call; }
inline bool lt(Function inOther) { return call < inOther.call; }
inline bool gt(Function inOther) { return call > inOther.call; }
inline bool leq(Function inOther) { return call <= inOther.call; }
inline bool geq(Function inOther) { return call >= inOther.call; }
};
template<typename T>
inline bool operator == (const null &, Function<T> inPtr) { return inPtr.call==0; }
template<typename T>
inline bool operator != (const null &, Function<T> inPtr) { return inPtr.call!=0; }
class Function_obj
{
public:
inline static AutoCast getProcAddress(String inLib, String inPrim)
{
return AutoCast(__hxcpp_get_proc_address(inLib, inPrim,false));
}
template<typename T>
inline static AutoCast fromStaticFunction(T *inFunction)
{
return AutoCast(inFunction);
}
};
class Pointer_obj
{
public:
template<typename T>
inline static AutoCast arrayElem(::Array<T> array, int inIndex) { return AutoCast(&array[inIndex]); }
inline static AutoCast arrayElem(Dynamic inVal, int inIndex)
{
if (inVal==null() || !inVal->__IsArray())
return AutoCast(0);
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
return AutoCast(base->GetBase() + inIndex*base->GetElementSize());
}
template<typename T>
inline static AutoCast ofArray(::Array<T> array) { return AutoCast(&array[0]); }
inline static AutoCast ofArray(Dynamic inVal)
{
if (inVal==null() || !inVal->__IsArray())
return AutoCast(0);
hx::ArrayBase *base = (hx::ArrayBase *)inVal.GetPtr();
return AutoCast(base->GetBase());
}
template<typename T>
inline static Pointer<T> addressOf(T &value) { return Pointer<T>(&value); }
template<typename T>
inline static Pointer<void> endOf(hx::ObjectPtr<T> value) { return (void *)(value.mPtr+1); }
template<typename T>
inline static Pointer<T> fromPointer(T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromPointer(const T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromRaw(T *value) { return Pointer<T>(value); }
template<typename T>
inline static Pointer<T> fromRaw(const T *value) { return Pointer<T>(value); }
inline static Pointer<void> fromRaw(const AutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
inline static Pointer<void> fromRaw(const RawAutoCast &inAutoCast) { return Pointer<void>(inAutoCast.value); }
inline static AutoCast fromHandle(Dynamic inValue, String inKind)
{
if (inValue==null() || (inKind!=null() && inKind!=__hxcpp_get_kind(inValue)))
return AutoCast(0);
return AutoCast(inValue->__GetHandle());
}
};
class Reference_obj
{
public:
};
} // end namespace cpp
namespace hx
{
template <typename T>
T *StarOf(T &x) { return &x; }
}
#endif

676
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/Variant.h Normal file
View File

@ -0,0 +1,676 @@
#ifndef CPP_VARIANT_TWICE_H
namespace cpp
{
#ifndef CPP_VARIANT_ONCE_H
#define CPP_VARIANT_ONCE_H
template<typename T>
inline bool isIntType(const T &inRHS) { return false; }
template<> inline bool isIntType(const int &inRHS) { return true; }
template<> inline bool isIntType(const Dynamic &inRHS);
template<> inline bool isIntType(const cpp::Variant &inRHS);
template<typename T>
inline bool isStringType(const T &inRHS) { return false; }
template<> inline bool isStringType(const String &inRHS) { return true; }
template<> inline bool isStringType(const Dynamic &inRHS);
template<> inline bool isStringType(const cpp::Variant &inRHS);
struct Variant
{
enum Type
{
typeObject = 0,
typeString,
typeDouble,
typeInt,
typeInt64,
typeBool,
};
union
{
// Although this is typed as 'char', it might be char16_t in the case of smart strings
const char *valStringPtr;
hx::Object *valObject;
double valDouble;
cpp::Int64 valInt64;
int valInt;
bool valBool;
};
Type type;
unsigned int valStringLen;
inline bool isNull() const {
return (type==typeObject && !valObject) || (type==typeString && !valStringPtr); }
inline bool isNumeric() const;
inline bool isBool() const;
inline int asInt() const;
inline bool isInt() const;
inline cpp::Int64 asInt64() const;
inline bool isInt64() const;
inline bool isString() const;
inline double asDouble() const;
inline hx::Object *asObject() const { return type==typeObject ? valObject : 0; }
inline hx::Object *asDynamic() const{ return type==typeObject ? valObject : toDynamic(); }
inline hx::Object *toDynamic() const; // later
inline String asString() const;
inline String getString() const;
inline Variant() : valInt64(0), type(typeObject) { }
//inline Variant() { copyBuf.b[0] = copyBuf.b[1] = 0; }
inline Variant(const null &) : type(typeObject), valObject(0) { }
inline Variant(bool inValue) : type(typeBool), valBool(inValue) { }
inline Variant(double inValue) : type(typeDouble), valDouble(inValue) { }
inline Variant(const ::String &inValue); // later
inline Variant(cpp::Int64 inValue) : type(typeInt64), valInt64(inValue) { }
inline Variant(cpp::UInt64 inValue) : type(typeInt64), valInt64(inValue) { }
inline Variant(int inValue) : type(typeInt), valInt(inValue) { }
inline Variant(cpp::UInt32 inValue) : type(typeInt), valInt(inValue) { }
inline Variant(cpp::Int16 inValue) : type(typeInt), valInt(inValue) { }
inline Variant(cpp::UInt16 inValue) : type(typeInt), valInt(inValue) { }
inline Variant(cpp::Int8 inValue) : type(typeInt), valInt(inValue) { }
inline Variant(cpp::UInt8 inValue) : type(typeInt), valInt(inValue) { }
#if defined(__OBJC__) && defined(HXCPP_OBJC)
inline Variant(const id inObjc);
inline operator id() const;
#endif
template<typename SOURCE_>
Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr);
inline Variant(const Dynamic &inRHS); // later
inline Variant(hx::Object *inValue) : type(typeObject), valObject(inValue) { }
template<typename T,typename H>
explicit inline Variant(const cpp::Struct<T,H> &inVal);
template<typename T>
explicit inline Variant(const cpp::Pointer<T> &inRHS) ;
template<typename T>
explicit inline Variant(const cpp::Function<T> &inRHS) ;
template<typename T>
explicit inline Variant(const hx::Native<T> &inRHS) ;
//inline operator Dynamic() const; // later
//inline operator String() const;
inline operator double() const { return asDouble(); }
inline operator int() const { return asInt(); }
inline operator bool() const { return asInt(); }
inline operator float () const { return asDouble(); }
inline operator unsigned int () const { return asInt(); }
inline operator short () const { return asInt(); }
inline operator unsigned short () const { return asInt(); }
inline operator unsigned char () const { return asInt(); }
inline operator char () const { return asInt(); }
inline operator signed char () const { return asInt(); }
inline operator cpp::Int64 () const { return asInt64(); }
inline operator cpp::UInt64 () const { return asInt64(); }
inline bool operator !() const { return !asInt(); }
inline int Compare(hx::Object *inRHS) const;
inline int Compare(const Dynamic &inRHS) const;
inline int Compare(const cpp::Variant &inRHS) const;
inline double set(const double &inValue) { type=typeDouble; return valDouble=inValue; }
inline double set(const float &inValue) { type=typeDouble; return valDouble=inValue; }
inline void mark(hx::MarkContext *__inCtx); // later
#ifdef HXCPP_VISIT_ALLOCS
inline void visit(hx::VisitContext *__inCtx); // later
#endif
//inline Variant &operator=(const Variant &inRhs) { copyBuf = inRhs.copyBuf; return *this; }
template<typename T>
bool operator==(const T &inRHS) const;
template<typename T>
bool operator==(const hx::ObjectPtr<T> &inRHS) const
{ return Compare(inRHS.mPtr)==0; }
template<typename T>
bool operator!=(const hx::ObjectPtr<T> &inRHS) const
{ return Compare(inRHS.mPtr)!=0; }
inline bool operator==(const null &inRHS) const { return isNull(); }
inline bool operator==(const String &inRHS) const;
inline bool operator!=(const null &inRHS) const { return !isNull(); }
inline bool operator!=(const Variant &inRHS) const { return !operator==(inRHS); }
inline bool operator!=(const String &inRHS) const;
template<typename RETURN_>
RETURN_ Cast() const { return RETURN_(*this); }
void CheckFPtr();
HX_DECLARE_VARIANT_FUNCTIONS
// Operator + is different, since it must consider strings too...
inline String operator+(const String &s) const;
template<typename T>
inline cpp::Variant operator + (const T &inRHS) const;
inline double operator%(const Dynamic &inRHS) const;
inline double operator-() const { return -asDouble(); }
inline double operator++() { return set(asDouble()+1); }
inline double operator++(int) {double val = asDouble(); set(val+1); return val; }
inline double operator--() { return set(asDouble()-1); }
inline double operator--(int) {double val = asDouble(); set(val-1); return val; }
template<typename T>
inline double operator / (const T &inRHS) const { return asDouble() / (double)inRHS; } \
template<typename T>
inline cpp::Variant operator - (const T &inRHS) const
{
if (::cpp::isIntType(inRHS) && isInt() )
return asInt() - (int)inRHS;
return asDouble() - (double)inRHS;
}
template<typename T>
inline cpp::Variant operator * (const T &inRHS) const
{
if (::cpp::isIntType(inRHS) && isInt())
return asInt() * (int)inRHS;
return asDouble() * (double)inRHS;
}
inline bool operator < (const String &inRHS) const;
inline bool operator <= (const String &inRHS) const;
inline bool operator > (const String &inRHS) const;
inline bool operator >= (const String &inRHS) const;
#define HX_VARIANT_COMPARE_OP( op ) \
inline bool operator op (double inRHS) const { return isNumeric() && (asDouble() op inRHS); } \
inline bool operator op (cpp::Int64 inRHS) const { return isNumeric() && (asInt64() op inRHS); } \
inline bool operator op (cpp::UInt64 inRHS) const { return isNumeric() && ((cpp::UInt64)(asInt64()) op inRHS); } \
inline bool operator op (float inRHS) const { return isNumeric() && (asDouble() op inRHS); } \
inline bool operator op (int inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (unsigned int inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (short inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (unsigned short inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (signed char inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (unsigned char inRHS) const { return isNumeric() && (asDouble() op (double)inRHS); } \
inline bool operator op (bool inRHS) const { return isBool() && (asDouble() op (double)inRHS); } \
inline bool operator op (const Dynamic &inRHS) const { return Compare(inRHS) op 0; } \
#define HX_VARIANT_COMPARE_OP_ALL( op ) \
inline bool operator op (const null &inRHS) const { return false; } \
inline bool operator op (const cpp::Variant &inRHS) const { return Compare(inRHS) op 0; } \
HX_VARIANT_COMPARE_OP(op)
HX_VARIANT_COMPARE_OP( == )
HX_VARIANT_COMPARE_OP( != )
HX_VARIANT_COMPARE_OP_ALL( < )
HX_VARIANT_COMPARE_OP_ALL( <= )
HX_VARIANT_COMPARE_OP_ALL( >= )
HX_VARIANT_COMPARE_OP_ALL( > )
};
#else // Second time ...
#define CPP_VARIANT_TWICE_H
bool Variant::isInt() const
{
return type==typeInt || (type==typeObject && valObject && valObject->__GetType()==vtInt);
}
bool Variant::isInt64() const
{
return type==typeInt64 || (type==typeObject && valObject && valObject->__GetType()==vtInt64);
}
bool Variant::isString() const
{
return type==typeString || (type==typeObject && valObject && valObject->__GetType()==vtString);
}
#if defined(__OBJC__) && defined(HXCPP_OBJC)
// Variant type neither adds nor releases references counts while holding the value as an id on the stack
// The Dynamic created here owns the id, and we refer to the Dynamic and use his reference count to keep the id alive
inline Variant::Variant(const id inObjc) { type=typeObject; valObject = Dynamic(inObjc).mPtr; }
#ifdef OBJC_ARC
inline Variant::operator id () const { return type==typeObject && valObject ? (__bridge id)valObject->__GetHandle() : 0; }
#else
inline Variant::operator id () const { return type==typeObject && valObject ? (id)valObject->__GetHandle() : 0; }
#endif
#endif
template<> inline bool isIntType(const Dynamic &inRHS) { return inRHS->__GetType()==vtInt; }
template<> inline bool isIntType(const cpp::Variant &inRHS) { return inRHS.isInt(); }
template<> inline bool isStringType(const Dynamic &inRHS) { return inRHS.mPtr && inRHS->__GetType()==vtString; }
template<> inline bool isStringType(const cpp::Variant &inRHS) { return inRHS.isString(); }
template<typename T,typename H>
Variant::Variant(const cpp::Struct<T,H> &inVal) :
type(typeObject), valObject(Dynamic(inVal).mPtr) { }
template<typename T>
Variant::Variant(const cpp::Pointer<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
template<typename T>
Variant::Variant(const cpp::Function<T> &inRHS) : type(typeObject), valObject( Dynamic(inRHS).mPtr ) { }
template<typename T>
Variant::Variant(const hx::Native<T> &inRHS) : type(typeObject), valObject( CreateDynamicPointer(inRHS.ptr).mPtr ) { }
#define HX_ARITH_VARIANT( op ) \
inline double operator op (const double &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
inline double operator op (const float &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS;} \
inline double operator op (const int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const signed char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const signed short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const unsigned short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const cpp::Int64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
inline double operator op (const cpp::UInt64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
HX_ARITH_VARIANT( - )
HX_ARITH_VARIANT( + )
HX_ARITH_VARIANT( / )
HX_ARITH_VARIANT( * )
inline bool Variant::operator==(const String &inString) const
{
if (isNull()) return inString==null();
return type==typeString && asString()==inString;
}
inline bool Variant::operator!=(const String &inString) const
{
if (isNull()) return inString!=null();
return type!=typeString || asString()!=inString;
}
inline bool Variant::operator < (const String &inRHS) const { return asString() < inRHS; }
inline bool Variant::operator <= (const String &inRHS) const { return asString() < inRHS; }
inline bool Variant::operator > (const String &inRHS) const { return asString() > inRHS; }
inline bool Variant::operator >= (const String &inRHS) const { return asString() >= inRHS; }
Variant::Variant(const ::String &inValue) :
type(typeString), valStringPtr(inValue.raw_ptr()), valStringLen(inValue.length) { }
Variant::Variant(const Dynamic &inRHS) : type(typeObject), valObject(inRHS.mPtr) { }
template<typename SOURCE_>
Variant::Variant(const hx::ObjectPtr<SOURCE_> &inObjectPtr) :
type(typeObject), valObject(inObjectPtr.mPtr) { }
inline void Variant::CheckFPtr()
{
if (isNull()) Dynamic::ThrowBadFunctionError();
}
HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS
int Variant::asInt() const
{
if (type==typeInt)
return valInt;
switch(type)
{
case typeDouble: return valDouble;
case typeInt64: return (int)valInt64;
case typeBool: return valBool;
case typeObject: return valObject ? valObject->__ToInt() : 0;
default: ;
}
return 0;
}
cpp::Int64 Variant::asInt64() const
{
if (type==typeInt64)
return valInt64;
switch(type)
{
case typeDouble: return valDouble;
case typeInt: return valInt;
case typeBool: return valBool;
case typeObject: return valObject ? valObject->__ToInt64() : 0;
default: ;
}
return 0;
}
double Variant::asDouble() const
{
if (type==typeDouble)
return valDouble;
else if (type==typeInt)
return valInt;
else if (type==typeBool)
return valBool ? 1.0 : 0.0;
else if (type==typeInt64)
return valInt64;
else if (type==typeObject)
return valObject ? valObject->__ToDouble() : 0.0;
return 0.0;
}
inline hx::Object *Variant::toDynamic() const
{
switch(type)
{
case typeInt: return Dynamic(valInt).mPtr;
case typeDouble: return Dynamic(valDouble).mPtr;
case typeBool: return Dynamic(valBool).mPtr;
case typeString: return Dynamic(String(valStringPtr, valStringLen)).mPtr;
case typeInt64: return Dynamic(valInt64).mPtr;
case typeObject: return valObject;
default: ;
}
return 0;
}
/*
Variant::operator Dynamic() const
{
switch(type)
{
case typeInt: return valInt;
case typeDouble: return valDouble;
case typeBool: return valBool;
case typeString: return String(valStringPtr, valStringLen);
case typeObject: return valObject;
default: ;
}
return null();
}
*/
bool Variant::isNumeric() const
{
if (type==typeInt || type==typeDouble || type==typeInt64)
return true;
if (type!=typeObject || valObject==0)
return false;
int t = valObject->__GetType();
return t==vtInt || t==vtFloat;
}
bool Variant::isBool() const
{
if (type==typeBool)
return true;
if (type!=typeObject || valObject==0)
return false;
return valObject->__GetType() == vtBool;
}
String Variant::getString() const { return String(valStringPtr, valStringLen); }
String Variant::asString() const
{
switch(type)
{
case typeInt: return String(valInt);
case typeDouble: return String(valDouble);
case typeBool: return String(valBool);
case typeString: return String(valStringPtr, valStringLen);
case typeInt64: return String(valInt64);
case typeObject: return valObject ? valObject->toString() : String();
default: ;
}
return String();
}
//Variant::operator String() const { return asString(); }
void Variant::mark(hx::MarkContext *__inCtx)
{
if (type==typeString)
{
HX_MARK_STRING(valStringPtr);
}
else if (type==typeObject)
{
HX_MARK_OBJECT(valObject);
}
}
template<typename T>
bool Variant::operator==(const T &inRHS) const
{
switch(type)
{
case typeInt: return valInt==(double)inRHS;
case typeDouble:return valDouble==(double)inRHS;
case typeBool: return valBool==(bool)inRHS;
case typeInt64: return valInt64==(cpp::Int64)inRHS;
case typeString: return getString()==String(inRHS);
case typeObject:
if (!valObject)
return inRHS == null();
return valObject->__Compare( Dynamic(inRHS).mPtr )==0;
}
return false;
}
int Variant::Compare(hx::Object *inPtr) const
{
if (!inPtr)
return isNull() ? 0 : 1;
switch(type)
{
case typeInt:
{
double diff = valInt - inPtr->__ToDouble();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeDouble:
{
double diff = valDouble - inPtr->__ToDouble();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeInt64:
{
cpp::Int64 diff = valInt64 - inPtr->__ToInt64();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeBool:
if (!inPtr) return 1;
return valBool==(bool)(inPtr->__ToInt()) ? 1 : 0;
case typeString:
if (!inPtr) return valStringPtr ? 1 : 0;
if (inPtr->__GetType()!=vtString)
return 1;
return String(valStringPtr, valStringLen)==inPtr->toString() ? 1 : 0;
case typeObject:
#if (HXCPP_API_LEVEL>=331)
return valObject->__Compare( inPtr );
#else
return valObject->__Compare( inPtr->__GetRealObject() );
#endif
default: ;
}
return 0;
}
int Variant::Compare(const Dynamic &inD) const { return Compare(inD.mPtr); }
int Variant::Compare(const cpp::Variant &inVar) const
{
if (inVar.type==typeObject)
return Compare(inVar.valObject);
switch(type)
{
case typeInt:
{
double diff = valInt - inVar.asDouble();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeDouble:
{
double diff = valDouble - inVar.asDouble();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeInt64:
{
cpp::Int64 diff = valInt64 - inVar.asInt64();
return diff<0 ? -1 : diff==0 ? 0 : 1;
}
case typeBool:
return valBool==(bool)(inVar.asInt()) ? 1 : 0;
case typeString:
if (inVar.type!=typeString)
return 1;
return String(valStringPtr, valStringLen)==inVar.asString();
case typeObject:
if (!valObject)
return 1;
return - inVar.Compare(*this);
}
return 0;
}
String cpp::Variant::operator+(const String &s) const
{
return asString() + s;
}
template<typename T>
cpp::Variant Variant::operator + (const T &inRHS) const
{
if (isString() || ::cpp::isStringType(inRHS))
return asString() + String(inRHS);
return asDouble() + (double)inRHS;
}
#ifdef HXCPP_VISIT_ALLOCS
void Variant::visit(hx::VisitContext *__inCtx)
{
if (type==typeString)
{
HX_VISIT_STRING(valStringPtr);
}
else if (type==typeObject)
{
HX_VISIT_OBJECT(valObject);
}
}
#endif // HXCPP_VISIT_ALLOCS
#define HX_VARIANT_OP_ISEQ(T) \
inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
#define HX_VARIANT_OP_ISEQ(T) \
inline bool operator == (const T &inLHS,const cpp::Variant &inRHS) { return inRHS==inLHS; } \
inline bool operator != (const T &inLHS,const cpp::Variant &inRHS) { return inRHS!=inLHS; }
HX_VARIANT_OP_ISEQ(String)
HX_VARIANT_OP_ISEQ(double)
HX_VARIANT_OP_ISEQ(float)
HX_VARIANT_OP_ISEQ(cpp::Int64)
HX_VARIANT_OP_ISEQ(cpp::UInt64)
HX_VARIANT_OP_ISEQ(int)
HX_VARIANT_OP_ISEQ(unsigned int)
HX_VARIANT_OP_ISEQ(short)
HX_VARIANT_OP_ISEQ(unsigned short)
HX_VARIANT_OP_ISEQ(signed char)
HX_VARIANT_OP_ISEQ(unsigned char)
HX_VARIANT_OP_ISEQ(bool)
inline bool operator < (bool inLHS,const cpp::Variant &inRHS) { return false; }
inline bool operator <= (bool inLHS,const cpp::Variant &inRHS) { return false; }
inline bool operator >= (bool inLHS,const cpp::Variant &inRHS) { return false; }
inline bool operator > (bool inLHS,const cpp::Variant &inRHS) { return false; }
#define HX_COMPARE_VARIANT_OP( op ) \
inline bool operator op (double inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (float inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && ((double)inLHS op (double)inRHS); } \
inline bool operator op (cpp::Int64 inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (cpp::UInt64 inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (int inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (unsigned int inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (short inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (unsigned short inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (signed char inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (unsigned char inLHS,const ::cpp::Variant &inRHS) \
{ return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
inline bool operator op (const null &,const ::cpp::Variant &inRHS) \
{ return false; } \
HX_COMPARE_VARIANT_OP( < )
HX_COMPARE_VARIANT_OP( <= )
HX_COMPARE_VARIANT_OP( >= )
HX_COMPARE_VARIANT_OP( > )
} // close cpp
namespace hx {
template<typename T>
bool ObjectPtr<T>::operator==(const cpp::Variant &inRHS) const {
return inRHS.Compare(mPtr)==0;
}
template<typename T>
bool ObjectPtr<T>::operator!=(const cpp::Variant &inRHS) const {
return inRHS.Compare(mPtr)!=0;
}
} // close hx
namespace cpp {
#endif // not twice
} // end namespace cpp
#endif // CPP_VARIANT_TWICE_H

727
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp/VirtualArray.h Normal file
View File

@ -0,0 +1,727 @@
namespace cpp
{
// This file is included twice - either side of the Array definition
#ifndef HX_VARRAY_DEFINED
#define HX_VARRAY_DEFINED
class VirtualArray : public hx::ObjectPtr<VirtualArray_obj>
{
typedef hx::ObjectPtr<VirtualArray_obj> super;
public:
typedef Dynamic Elem;
inline VirtualArray() : super(0) { }
inline VirtualArray(VirtualArray_obj *inObj) : super(inObj) { }
inline VirtualArray(const null &inNull) : super(0) { }
inline VirtualArray(const VirtualArray &inOther) : super( inOther.mPtr ) { }
// Build from foreign array
template<typename SOURCE_> inline VirtualArray( const Array<SOURCE_> &inRHS );
inline VirtualArray( const Dynamic &inRHS ) : super(0) { setDynamic(inRHS); }
inline VirtualArray( const cpp::ArrayBase &inRHS ) : super(0) { setDynamic(inRHS); }
inline VirtualArray(const ::cpp::Variant &inVariant) { setDynamic(inVariant.asObject()); }
inline VirtualArray &operator=(const null &inNull) { mPtr = 0; return *this; }
inline VirtualArray &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
inline VirtualArray &operator=(const VirtualArray &inRHS) { mPtr = inRHS.mPtr; return *this; }
inline void setDynamic( const Dynamic &inRHS );
template<typename T>
inline VirtualArray Add(const T &inVal);
inline bool operator==(const Dynamic &value) const { return value==*this; }
template<typename SOURCE_> inline bool operator==( const Array<SOURCE_> &inRHS );
inline bool operator!=(Dynamic value) const { return value!=*this; }
template<typename SOURCE_> inline bool operator!=( const Array<SOURCE_> &inRHS ) { return inRHS!=*this; }
};
class HXCPP_EXTERN_CLASS_ATTRIBUTES VirtualArray_obj : public hx::ArrayCommon
{
typedef hx::ArrayStore ArrayStore;
typedef hx::ArrayBase ArrayBase;
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdVirtualArray };
typedef hx::Object super;
ArrayStore store;
ArrayBase *base;
VirtualArray_obj(ArrayBase *inBase=0, bool inFixed=false) : base(inBase)
{
mArrayConvertId = hx::aciVirtualArray;
store = inFixed && inBase ? hx::arrayFixed : base ? base->getStoreType() : hx::arrayEmpty;
#ifdef HXCPP_GC_GENERATIONAL
if (base)
HX_OBJ_WB_GET(this,base);
#endif
}
VirtualArray_obj(ArrayStore inStore)
{
mArrayConvertId = hx::aciVirtualArray;
store = inStore;
}
hx::Object *__GetRealObject() { return base?(hx::Object *)base:(hx::Object *)this; }
inline static VirtualArray __new(int inSize=0,int inReserve=0)
{
VirtualArray result = new VirtualArray_obj(hx::arrayEmpty);
if (inSize>0)
result->__SetSizeExact(inSize);
if (inReserve>0)
result->reserve(inReserve);
return result;
}
#if (HXCPP_API_LEVEL>330)
int __Compare(const hx::Object *inRHS) const;
#endif
inline int get_length() const
{
return base ? base->length : 0;
}
inline void checkBase() const
{
#ifdef HXCPP_CHECK_POINTER
if (store==hx::arrayNull)
{
hx::NullReference("Array", true);
// The handler might have fixed up the null value
if (store==hx::arrayNull) hx::NullReference("Array", false);
}
#endif
}
void EnsureStorage(const Dynamic &inValue)
{
if (!inValue.mPtr)
{
EnsureNullStorage();
}
else switch(inValue->__GetType())
{
case vtBool: EnsureBoolStorage(); break;
case vtInt: EnsureIntStorage(); break;
case vtFloat: EnsureFloatStorage(); break;
case vtString: EnsureStringStorage(); break;
case vtInt64: EnsureInt64Storage(); break;
default: EnsureObjectStorage();
}
}
void EnsureStorage(const cpp::Variant &inValue)
{
switch(inValue.type)
{
case Variant::typeObject:
if (!inValue.valObject)
EnsureNullStorage();
else
EnsureObjectStorage();
break;
case Variant::typeString: EnsureStringStorage(); break;
case Variant::typeDouble: EnsureFloatStorage(); break;
case Variant::typeInt: EnsureIntStorage(); break;
case Variant::typeBool: EnsureBoolStorage(); break;
case Variant::typeInt64: EnsureInt64Storage(); break;
}
}
void MakeIntArray();
void MakeInt64Array();
void MakeObjectArray();
void MakeFloatArray();
void MakeBoolArray();
void MakeStringArray();
void EnsureStorage(const VirtualArray &inValue) { EnsureObjectStorage(); }
void EnsureStorage(const unsigned char &inValue) { EnsureIntStorage(); }
void EnsureStorage(const bool &inValue) { EnsureBoolStorage(); }
void EnsureStorage(const String &inValue) { EnsureStringStorage(); }
void EnsureStorage(const double &inValue) { EnsureFloatStorage(); }
void EnsureStorage(const float &inValue) { EnsureFloatStorage(); }
void EnsureStorage(const int &inValue) { EnsureIntStorage(); }
void EnsureStorage(const cpp::Int64 &inValue) { EnsureInt64Storage(); }
void EnsureStorage(const cpp::UInt64 &inValue) { EnsureInt64Storage(); }
void EnsureStorage(const null &inValue) { EnsureNullStorage(); }
template<typename T>
void EnsureStorage(const T &inValue) { EnsureObjectStorage(); }
inline void EnsureBoolStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayObject:
case hx::arrayFixed:
case hx::arrayBool:
return;
case hx::arrayEmpty:
MakeBoolArray();
break;
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayString:
MakeObjectArray();
break;
}
}
inline void EnsureStringStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayObject:
case hx::arrayFixed:
case hx::arrayString:
return;
case hx::arrayEmpty:
MakeStringArray();
break;
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayBool:
MakeObjectArray();
break;
}
}
inline void EnsureFloatStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayFloat:
case hx::arrayObject:
case hx::arrayFixed:
return;
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayEmpty:
MakeFloatArray();
break;
case hx::arrayBool:
case hx::arrayString:
MakeObjectArray();
break;
}
}
inline void EnsureIntStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayObject:
case hx::arrayFixed:
return;
case hx::arrayEmpty:
MakeIntArray();
break;
case hx::arrayBool:
case hx::arrayString:
MakeObjectArray();
break;
}
}
inline void EnsureInt64Storage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayObject:
case hx::arrayFixed:
return;
case hx::arrayInt:
case hx::arrayEmpty:
MakeInt64Array();
break;
case hx::arrayBool:
case hx::arrayString:
MakeObjectArray();
break;
}
}
inline void EnsureObjectStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayObject:
case hx::arrayFixed:
return;
case hx::arrayEmpty:
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayBool:
case hx::arrayString:
MakeObjectArray();
break;
}
}
inline void EnsureNullStorage()
{
switch(store)
{
case hx::arrayNull:
case hx::arrayObject:
case hx::arrayFixed:
case hx::arrayString:
return;
case hx::arrayEmpty:
case hx::arrayInt:
case hx::arrayInt64:
case hx::arrayFloat:
case hx::arrayBool:
MakeObjectArray();
break;
}
}
template<typename F> void fixType();
template<typename F> F castArray();
void EnsureBase();
void CreateEmptyArray(int inLen);
void EnsureArrayStorage(ArrayStore inValue);
void EnsureArrayStorage(VirtualArray inValue);
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_OBJECT(base);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
if (base)
__inCtx->visitObject( (hx::Object **)&base);
}
#endif
// Used by cpp.ArrayBase
inline int getElementSize() const { return base ? base->GetElementSize() : 0; }
inline int getByteCount() const { return base ? base->getByteCount() : 0; }
inline char * getBase() const { return base ? base->GetBase() : 0; }
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp) { return null(); }
static hx::Class &__SGetClass() { return hx::ArrayBase::__mClass; }
hx::Class __GetClass() const;
String toString();
String __ToString() const { return const_cast<VirtualArray_obj *>(this)->toString(); }
void setData(void *inData, int inElements) { EnsureBase(); base->setData(inData, inElements); }
void setUnmanagedData(void *inData, int inElements) { EnsureBase(); base->setUnmanagedData(inData, inElements); }
int __GetType() const { return vtArray; }
inline size_t size() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->length; }
inline int __length() const { checkBase(); return store==hx::arrayEmpty ? 0 : (int)base->length; }
String ItemString(int inI) { checkBase(); return store==hx::arrayEmpty ? null() : base->ItemString(inI); }
const char * __CStr() const { return store==hx::arrayEmpty ? "[]" : store==hx::arrayNull ? "null" : base->__CStr(); }
inline const char *GetBase() const { return base ? base->GetBase() : 0; }
inline char *GetBase() { return base ? base->GetBase() : 0; }
int GetElementSize() const { checkBase(); return store==hx::arrayEmpty ? 0 : base->GetElementSize(); }
inline void reserve(int inSize) const
{
if (base)
base->reserve(inSize);
}
inline int capacity()
{
if (base)
return base->capacity();
return 0;
}
void resize(int inLen)
{
if (!base)
CreateEmptyArray(inLen);
else
base->resize(inLen);
}
void __SetSize(int inLen) { resize(inLen); }
VirtualArray __SetSizeExact(int inLen=0)
{
if (!base && inLen)
CreateEmptyArray(inLen);
else if (base)
base->__SetSizeExact(inLen);
return this;
}
void safeSort(Dynamic sorter, bool isString) { checkBase(); if (store!=hx::arrayEmpty) base->safeSort(sorter,isString); }
inline void __unsafeStringReference(String inString) { if (base) base->__unsafeStringReference(inString); }
Dynamic __GetItem(int inIndex) const;
Dynamic __SetItem(int inIndex,Dynamic inValue);
hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
template<typename T>
inline const T &set(int inIdx, const T &inVal)
{
if (store!=hx::arrayFixed)
{
if (inIdx>(store==hx::arrayEmpty ? 0 : (int)base->length) )
EnsureObjectStorage();
else
EnsureStorage(inVal);
}
base->set(inIdx, inVal);
return inVal;
}
template<typename T>
inline int push(const T &inVal)
{
if (store!=hx::arrayFixed) EnsureStorage(inVal);
return base->__push(Dynamic(inVal));
}
template<typename T>
inline VirtualArray_obj *Add(const T &inVal)
{
if (store!=hx::arrayFixed) EnsureStorage(inVal);
base->__push(Dynamic(inVal));
return this;
}
inline Dynamic pop() { checkBase(); return store==hx::arrayEmpty ? null() : base->__pop(); }
inline bool contains(Dynamic inValue)
{
checkBase();
if (store==hx::arrayEmpty)
return false;
EnsureStorage(inValue);
return base->__contains(inValue);
}
inline bool remove(Dynamic inValue)
{
checkBase();
if (store==hx::arrayEmpty)
return false;
EnsureStorage(inValue);
return base->__remove(inValue);
}
inline bool removeAt(int inIndex) { checkBase(); return (store!=hx::arrayEmpty) && base->__removeAt(inIndex); }
int indexOf(Dynamic inValue, Dynamic fromIndex = null())
{
checkBase();
if (store==hx::arrayEmpty)
return -1;
EnsureStorage(inValue);
return (int)base->__indexOf(inValue,fromIndex);
}
int lastIndexOf(Dynamic inValue, Dynamic fromIndex = null())
{
checkBase();
if (store==hx::arrayEmpty)
return -1;
EnsureStorage(inValue);
return (int)base->__lastIndexOf(inValue,fromIndex);
}
Dynamic shift() { checkBase(); return store==hx::arrayEmpty ? null() : base->__shift(); }
VirtualArray concat( VirtualArray inTail )
{
inTail->checkBase();
EnsureArrayStorage(inTail);
if (inTail->__length()<1)
return copy();
return new VirtualArray_obj( base->__concat(inTail), store==hx::arrayFixed );
}
VirtualArray copy( )
{
checkBase();
if (store==hx::arrayEmpty)
return new VirtualArray_obj(hx::arrayEmpty);
return new VirtualArray_obj(base->__copy(), store==hx::arrayFixed);
}
VirtualArray slice(int inPos, Dynamic end = null())
{
checkBase();
if (store==hx::arrayEmpty)
return new VirtualArray_obj(hx::arrayEmpty);
return new VirtualArray_obj(base->__slice(inPos,end), store==hx::arrayFixed);
}
VirtualArray splice(int inPos, int len);
VirtualArray map(Dynamic inFunc);
VirtualArray filter(Dynamic inFunc);
template<typename T>
inline VirtualArray init(int inIndex, const T &inVal)
{
if (store!=hx::arrayFixed) EnsureStorage(inVal);
__SetItem(inIndex,inVal);
return this;
}
inline Dynamic __unsafe_set(int inIndex, const Dynamic &val) { return __SetItem(inIndex,val); }
inline Dynamic __unsafe_get(int inIndex) { return __GetItem(inIndex); }
template<typename T>
inline void insert(int inPos, const T &inValue)
{
if (store!=hx::arrayFixed)
{
if (inPos>(store==hx::arrayEmpty ? 0 : (int)base->length) )
EnsureObjectStorage();
else
EnsureStorage(inValue);
}
base->__insert(inPos,inValue);
}
template<typename T>
inline void unshift(const T& inValue)
{
if (store!=hx::arrayFixed) EnsureStorage(inValue);
base->__unshift(inValue);
}
inline void reverse() { checkBase(); if (store!=hx::arrayEmpty) base->__reverse(); }
inline void qsort(Dynamic inSorter) { checkBase(); if (base) base->__qsort(inSorter); }
inline void sort(Dynamic inSorter) { checkBase(); if (base) base->__sort(inSorter); }
Dynamic iterator() { checkBase(); return !base ? getEmptyIterator() : base->__iterator(); }
static Dynamic getEmptyIterator();
Dynamic keyValueIterator() { checkBase(); return !base ? getEmptyIterator() : base->__keyValueIterator(); }
bool IsByteArray() const { checkBase(); return store!=hx::arrayEmpty && base->IsByteArray(); }
void zero(Dynamic inFirst, Dynamic inCount) { checkBase(); if (store!=hx::arrayEmpty) base->zero(inFirst,inCount); }
inline int memcmp(VirtualArray inOther)
{
checkBase();
if (store==hx::arrayEmpty)
return inOther->__length() == 0;
return base->__memcmp(inOther);
}
inline void blit(int inDestElement, cpp::VirtualArray inSourceArray, int inSourceElement, int inElementCount)
{
inSourceArray->checkBase();
EnsureArrayStorage(inSourceArray);
if (base)
base->__blit(inDestElement, inSourceArray, inSourceElement, inElementCount);
}
String join(String inSeparator) { checkBase(); if (!base) return HX_CSTRING(""); return base->__join(inSeparator); }
Dynamic __get(int inIndex) const { checkBase(); if (store==hx::arrayEmpty) return null(); return base->__GetItem(inIndex); }
Dynamic concat_dyn();
Dynamic copy_dyn();
Dynamic insert_dyn();
Dynamic iterator_dyn();
Dynamic keyValueIterator_dyn();
Dynamic join_dyn();
Dynamic pop_dyn();
Dynamic push_dyn();
Dynamic contains_dyn();
Dynamic remove_dyn();
Dynamic removeAt_dyn();
Dynamic indexOf_dyn();
Dynamic lastIndexOf_dyn();
Dynamic reverse_dyn();
Dynamic shift_dyn();
Dynamic slice_dyn();
Dynamic splice_dyn();
Dynamic sort_dyn();
Dynamic toString_dyn();
Dynamic unshift_dyn();
Dynamic map_dyn();
Dynamic filter_dyn();
Dynamic __SetSize_dyn();
Dynamic __SetSizeExact_dyn();
Dynamic __unsafe_get_dyn();
Dynamic __unsafe_set_dyn();
Dynamic blit_dyn();
Dynamic zero_dyn();
Dynamic memcmp_dyn();
Dynamic resize_dyn();
};
//typedef hx::ObjectPtr< VirtualArray_obj > VirtualArray;
#else // !HX_VARRAY_DEFINED
// Build dynamic array from foreign array
template<typename SOURCE_>
VirtualArray::VirtualArray( const Array<SOURCE_> &inRHS )
: super( !inRHS.mPtr ? 0 : new VirtualArray_obj( inRHS.mPtr, true) )
{
}
template<typename T>
inline VirtualArray VirtualArray::Add(const T &inVal)
{
mPtr->push(inVal);
return *this;
}
inline void VirtualArray::setDynamic( const Dynamic &inRHS )
{
hx::Object *ptr = inRHS.GetPtr();
if (ptr)
{
if (ptr->__GetClass().mPtr == super::__SGetClass().mPtr )
{
cpp::VirtualArray_obj *varray = dynamic_cast<cpp::VirtualArray_obj *>(ptr);
if (varray)
mPtr = varray;
else
mPtr = new VirtualArray_obj(dynamic_cast<cpp::ArrayBase_obj *>(ptr), true);
}
}
}
template<typename F>
void VirtualArray_obj::fixType()
{
if (store==hx::arrayFixed)
return;
store = hx::arrayFixed;
if (base && base->length>0)
{
Array<F> fixedArray = Dynamic(base);
base = fixedArray.mPtr;
}
else
{
base = new Array_obj<F>(0,0);
}
#ifdef HXCPP_GC_GENERATIONAL
if (base)
HX_OBJ_WB_GET(this,base);
#endif
}
template<typename ARRAY >
ARRAY VirtualArray_obj::castArray()
{
if (store==hx::arrayFixed)
return Dynamic(base);
store = hx::arrayFixed;
if (base && base->length>0)
{
ARRAY fixedArray = Dynamic(base);
base = fixedArray.mPtr;
#ifdef HXCPP_GC_GENERATIONAL
if (base)
HX_OBJ_WB_GET(this,base);
#endif
return fixedArray;
}
else
{
ARRAY fixedArray(0,0);
base = fixedArray.mPtr;
#ifdef HXCPP_GC_GENERATIONAL
if (base)
HX_OBJ_WB_GET(this,base);
#endif
return fixedArray;
}
}
template<typename SOURCE_>
inline bool VirtualArray::operator==( const Array<SOURCE_> &inRHS )
{
if (!mPtr)
return inRHS.mPtr;
return mPtr->castArray< Array<SOURCE_> >() == inRHS;
}
} // end namespace cpp
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_reslove_virtual_array(cpp::VirtualArray inArray);
namespace hx
{
// For type inference when marking
template<> inline void MarkMember(cpp::VirtualArray &outT,hx::MarkContext *__inCtx)
{ HX_MARK_OBJECT(outT.mPtr); }
#ifdef HXCPP_VISIT_ALLOCS
template<> inline void VisitMember(cpp::VirtualArray &outT,hx::VisitContext *__inCtx)
{
HX_VISIT_OBJECT(outT.mPtr);
}
#endif
} // end namespace hx
namespace cpp
{
#endif // HX_VARRAY_DEFINED
}

38
Kha/Backends/Kinc-hxcpp/khacpp/include/cpp_bytearray.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
#include <assert.h>
#include <stdint.h>
struct bytearray {
uint8_t *data;
int refCount;
bytearray() {
data = NULL;
refCount = 0;
}
void alloc(int length) {
data = new uint8_t[length];
}
void addRef() {
++refCount;
}
void subRef() {
--refCount;
if (refCount == 0) {
delete[] data;
data = NULL;
}
}
float get(int index) {
return data[index];
}
float set(int index, float value) {
return data[index] = value;
}
};

755
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Anon.h Normal file
View File

@ -0,0 +1,755 @@
#ifndef HX_ANON_H
#define HX_ANON_H
namespace hx
{
typedef Dynamic FieldMap;
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic FieldMapCreate();
HXCPP_EXTERN_CLASS_ATTRIBUTES
bool FieldMapGet(Dynamic *inMap, const ::String &inName, ::Dynamic &outValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES
bool FieldMapHas(Dynamic *inMap, const ::String &inName);
HXCPP_EXTERN_CLASS_ATTRIBUTES
bool FieldMapGet(Dynamic *inMap, int inID, ::Dynamic &outValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES
#ifdef HXCPP_GC_GENERATIONAL
void FieldMapSet(hx::Object *inThis,Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
#else
void FieldMapSet(Dynamic *inMap, const ::String &inName, const ::Dynamic &inValue);
#endif
HXCPP_EXTERN_CLASS_ATTRIBUTES
void FieldMapAppendFields(Dynamic *inMap,::Array< ::String> &outFields);
HXCPP_EXTERN_CLASS_ATTRIBUTES
void FieldMapMark(Dynamic *inMap,hx::MarkContext *__inCtx);
#ifdef HXCPP_VISIT_ALLOCS
HXCPP_EXTERN_CLASS_ATTRIBUTES
void FieldMapVisit(Dynamic **inMap,hx::VisitContext *__inCtx);
#endif
} // end namespace hx
namespace hx
{
// --- hx::Anon_obj ----------------------------------------------
//
// The hx::Anon_obj contains an arbitrary string map of fields.
class HXCPP_EXTERN_CLASS_ATTRIBUTES Anon_obj : public hx::Object
{
typedef hx::Anon_obj OBJ_;
typedef hx::ObjectPtr<hx::Anon_obj> Anon;
typedef hx::Object super;
inline void *operator new( size_t inSize, int inExtra )
{
return hx::Object::operator new(inSize+inExtra, true, 0);
}
struct VariantKey
{
int hash;
String key;
cpp::Variant value;
};
Dynamic mFields;
int mFixedFields;
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
inline void *operator new( size_t inSize )
{
return hx::Object::operator new(inSize, true, 0);
}
inline void operator delete(void *, size_t inSize ) { }
inline void operator delete(void *, size_t inSize, int inExtra ) { }
inline Anon_obj *setFixed(int index, const String &inName, const ::cpp::Variant &inValue)
{
VariantKey *fixed = getFixed() + index;
fixed->hash = inName.hash();
fixed->key = inName;
fixed->value = inValue;
if (inValue.type == ::cpp::Variant::typeObject) {
HX_OBJ_WB_GET(this, inValue.valObject);
}
else if (inValue.type == ::cpp::Variant::typeString) {
HX_OBJ_WB_GET(this, inValue.valStringPtr);
}
return this;
}
inline VariantKey *getFixed()
{
return (VariantKey *)(this + 1);
}
inline int findFixed(const ::String &inKey,bool inSkip5 = false);
Anon_obj(int inFixedFields = 0);
static Anon Create(int inElements)
{
return Anon(new (inElements*sizeof(VariantKey) ) hx::Anon_obj(inElements) );
}
static Anon Create() { return Anon(new (0) hx::Anon_obj); }
static Anon Create(const Dynamic &inSrc) { return Anon(new (0) hx::Anon_obj); }
static Dynamic __CreateEmpty() { return Anon(new (0) hx::Anon_obj); }
static Dynamic __Create(DynamicArray inArgs);
static void __boot();
void operator delete( void *, int) { }
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
bool __HasField(const String &inString);
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
virtual void __GetFields(Array<String> &outFields);
Dynamic *__GetFieldMap() { return &mFields; }
virtual int __GetType() const { return vtObject; }
hx::Anon_obj *Add(const String &inName,const Dynamic &inValue,bool inSetThisPointer=true);
void __Mark(hx::MarkContext *__inCtx);
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx);
#endif
String __ToString() const;
String toString();
static hx::ObjectPtr<hx::Class_obj> __mClass; \
static hx::ObjectPtr<hx::Class_obj> &__SGetClass() { return __mClass; }
#if (HXCPP_API_LEVEL<331)
bool __Is(hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
#endif
hx::ObjectPtr<hx::Class_obj > __GetClass() const { return __mClass; }
bool __Remove(String inKey);
};
typedef hx::ObjectPtr<hx::Anon_obj> Anon;
HXCPP_EXTERN_CLASS_ATTRIBUTES
Anon SourceInfo(String inFile, int inLine, String inClass, String inMethod);
HXCPP_EXTERN_CLASS_ATTRIBUTES String StringFromAnonFields(hx::Object *inPtr);
template<typename _hx_T0>
class AnonStruct1_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
String name0; _hx_T0 t0;
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0)
{
AnonStruct1_obj *result = new AnonStruct1_obj;
result->name0 = inName0; result->t0 = inT0;
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
}
return result;
}
hx::Val __Field(const String &inField, hx::PropertyAccess)
{
if (HX_QSTR_EQ(inField,name0)) return t0;
return null();
}
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
{
if (inField.__s==name0.__s || HX_QSTR_EQ(inField,name0)) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
hx::Throw(HX_CSTRING("Missing field ") + inField);
return inValue;
}
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER(t0);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER(t0);
}
#endif
void __GetFields(Array<String> &outFields)
{
outFields->push(name0);
}
String toString() { return StringFromAnonFields(this); }
};
template<typename _hx_T0, typename _hx_T1>
class AnonStruct2_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
String name0; _hx_T0 t0;
String name1; _hx_T1 t1;
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
const String &inName1, _hx_T1 inT1)
{
AnonStruct2_obj *result = new AnonStruct2_obj;
result->name0 = inName0; result->t0 = inT0;
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
}
result->name1 = inName1; result->t1 = inT1;
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
}
return result;
}
hx::Val __Field(const String &inField, hx::PropertyAccess)
{
if (inField.__s==name0.__s) return t0;
if (inField.__s==name1.__s) return t1;
#ifdef HX_SMART_STRINGS
if (!inField.isAsciiEncodedQ())
return null();
#endif
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
return null();
}
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
{
if (inField.__s==name0.__s) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (inField.__s==name1.__s) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name0)) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name1)) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
hx::Throw(HX_CSTRING("Missing field ") + inField);
return inValue;
}
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER(t0);
HX_MARK_MEMBER(t1);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER(t0);
HX_VISIT_MEMBER(t1);
}
#endif
void __GetFields(Array<String> &outFields)
{
outFields->push(name0);
outFields->push(name1);
}
String toString() { return StringFromAnonFields(this); }
};
template<typename _hx_T0, typename _hx_T1, typename _hx_T2>
class AnonStruct3_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
String name0; _hx_T0 t0;
String name1; _hx_T1 t1;
String name2; _hx_T2 t2;
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
const String &inName1, _hx_T1 inT1,
const String &inName2, _hx_T2 inT2)
{
AnonStruct3_obj *result = new AnonStruct3_obj;
result->name0 = inName0; result->t0 = inT0;
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
}
result->name1 = inName1; result->t1 = inT1;
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
}
result->name2 = inName2; result->t2 = inT2;
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
}
return result;
}
hx::Val __Field(const String &inField, hx::PropertyAccess)
{
if (inField.__s==name0.__s) return t0;
if (inField.__s==name1.__s) return t1;
if (inField.__s==name2.__s) return t2;
#ifdef HX_SMART_STRINGS
if (!inField.isAsciiEncodedQ())
return null();
#endif
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
return null();
}
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
{
if (inField.__s==name0.__s) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (inField.__s==name1.__s) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (inField.__s==name2.__s) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name0)) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name1)) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name2)) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
hx::Throw(HX_CSTRING("Missing field ") + inField);
return inValue;
}
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER(t0);
HX_MARK_MEMBER(t1);
HX_MARK_MEMBER(t2);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER(t0);
HX_VISIT_MEMBER(t1);
HX_VISIT_MEMBER(t2);
}
#endif
void __GetFields(Array<String> &outFields)
{
outFields->push(name0);
outFields->push(name1);
outFields->push(name2);
}
String toString() { return StringFromAnonFields(this); }
};
template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3>
class AnonStruct4_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
String name0; _hx_T0 t0;
String name1; _hx_T1 t1;
String name2; _hx_T2 t2;
String name3; _hx_T3 t3;
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
const String &inName1, _hx_T1 inT1,
const String &inName2, _hx_T2 inT2,
const String &inName3, _hx_T3 inT3
)
{
AnonStruct4_obj *result = new AnonStruct4_obj;
result->name0 = inName0; result->t0 = inT0;
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
}
result->name1 = inName1; result->t1 = inT1;
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
}
result->name2 = inName2; result->t2 = inT2;
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
}
result->name3 = inName3; result->t3 = inT3;
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
}
return result;
}
hx::Val __Field(const String &inField, hx::PropertyAccess)
{
if (inField.__s==name0.__s) return t0;
if (inField.__s==name1.__s) return t1;
if (inField.__s==name2.__s) return t2;
if (inField.__s==name3.__s) return t3;
#ifdef HX_SMART_STRINGS
if (!inField.isAsciiEncodedQ())
return null();
#endif
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
if (HX_QSTR_EQ_AE(inField,name3)) return t3;
return null();
}
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
{
if (inField.__s==name0.__s) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (inField.__s==name1.__s) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (inField.__s==name2.__s) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
if (inField.__s==name3.__s) {
t3 = inValue.Cast< _hx_T3 >();
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name0)) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name1)) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name2)) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name3)) {
t3 = inValue.Cast< _hx_T3 >();
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
}
return inValue;
}
hx::Throw(HX_CSTRING("Missing field ") + inField);
return inValue;
}
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER(t0);
HX_MARK_MEMBER(t1);
HX_MARK_MEMBER(t2);
HX_MARK_MEMBER(t3);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER(t0);
HX_VISIT_MEMBER(t1);
HX_VISIT_MEMBER(t2);
HX_VISIT_MEMBER(t3);
}
#endif
void __GetFields(Array<String> &outFields)
{
outFields->push(name0);
outFields->push(name1);
outFields->push(name2);
outFields->push(name3);
}
String toString() { return StringFromAnonFields(this); }
};
template<typename _hx_T0, typename _hx_T1, typename _hx_T2, typename _hx_T3, typename _hx_T4>
class AnonStruct5_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdDynamic };
String name0; _hx_T0 t0;
String name1; _hx_T1 t1;
String name2; _hx_T2 t2;
String name3; _hx_T3 t3;
String name4; _hx_T4 t4;
inline static hx::Object *Create(const String &inName0, _hx_T0 inT0,
const String &inName1, _hx_T1 inT1,
const String &inName2, _hx_T2 inT2,
const String &inName3, _hx_T3 inT3,
const String &inName4, _hx_T4 inT4
)
{
AnonStruct5_obj *result = new AnonStruct5_obj;
result->name0 = inName0; result->t0 = inT0;
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT0));
}
result->name1 = inName1; result->t1 = inT1;
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT1));
}
result->name2 = inName2; result->t2 = inT2;
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT2));
}
result->name3 = inName3; result->t3 = inT3;
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT3));
}
result->name4 = inName4; result->t4 = inT4;
if (hx::ContainsPointers<_hx_T4>()) {
HX_OBJ_WB_GET(result, hx::PointerOf(inT4));
}
return result;
}
hx::Val __Field(const String &inField, hx::PropertyAccess)
{
if (inField.__s==name0.__s) return t0;
if (inField.__s==name1.__s) return t1;
if (inField.__s==name2.__s) return t2;
if (inField.__s==name3.__s) return t3;
if (inField.__s==name4.__s) return t4;
#ifdef HX_SMART_STRINGS
if (!inField.isAsciiEncodedQ())
return null();
#endif
if (HX_QSTR_EQ_AE(inField,name0)) return t0;
if (HX_QSTR_EQ_AE(inField,name1)) return t1;
if (HX_QSTR_EQ_AE(inField,name2)) return t2;
if (HX_QSTR_EQ_AE(inField,name3)) return t3;
if (HX_QSTR_EQ_AE(inField,name4)) return t4;
return null();
}
hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp)
{
if (inField.__s==name0.__s) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (inField.__s==name1.__s) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (inField.__s==name2.__s) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
if (inField.__s==name3.__s) {
t3 = inValue.Cast< _hx_T3 >();
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
}
return inValue;
}
if (inField.__s==name4.__s) {
t4 = inValue.Cast< _hx_T4 >();
if (hx::ContainsPointers<_hx_T4>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t4));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name0)) {
t0 = inValue.Cast< _hx_T0 >();
if (hx::ContainsPointers<_hx_T0>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t0));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name1)) {
t1 = inValue.Cast< _hx_T1 >();
if (hx::ContainsPointers<_hx_T1>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t1));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name2)) {
t2 = inValue.Cast< _hx_T2 >();
if (hx::ContainsPointers<_hx_T2>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t2));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name3)) {
t3 = inValue.Cast< _hx_T3 >();
if (hx::ContainsPointers<_hx_T3>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t3));
}
return inValue;
}
if (HX_QSTR_EQ(inField,name4)) {
t4 = inValue.Cast< _hx_T4 >();
if (hx::ContainsPointers<_hx_T4>()) {
HX_OBJ_WB_GET(this, hx::PointerOf(t4));
}
return inValue;
}
hx::Throw(HX_CSTRING("Missing field ") + inField);
return inValue;
}
void __Mark(hx::MarkContext *__inCtx)
{
HX_MARK_MEMBER(t0);
HX_MARK_MEMBER(t1);
HX_MARK_MEMBER(t2);
HX_MARK_MEMBER(t3);
HX_MARK_MEMBER(t4);
}
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx)
{
HX_VISIT_MEMBER(t0);
HX_VISIT_MEMBER(t1);
HX_VISIT_MEMBER(t2);
HX_VISIT_MEMBER(t3);
HX_VISIT_MEMBER(t4);
}
#endif
void __GetFields(Array<String> &outFields)
{
outFields->push(name0);
outFields->push(name1);
outFields->push(name2);
outFields->push(name3);
outFields->push(name4);
}
String toString() { return StringFromAnonFields(this); }
};
} // end namespace hx
HXCPP_EXTERN_CLASS_ATTRIBUTES
bool __hxcpp_anon_remove(Dynamic inObj,::String inKey);
#endif

15
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Boot.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef HX_BOOT_H
#define HX_BOOT_H
// Properly construct all the classes defined in the haxe code
void __boot_all();
namespace hx
{
// Initializer the hxcpp runtime system
HXCPP_EXTERN_CLASS_ATTRIBUTES void Boot();
}
#endif

469
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFI.h Normal file
View File

@ -0,0 +1,469 @@
#ifndef HX_CFFI_H
#define HX_CFFI_H
// 410 - adds gc_try_unblocking
#define HX_CFFI_API_VERSION 410
#ifdef HXCPP_JS_PRIME
#include <emscripten/bind.h>
using namespace emscripten;
typedef struct emscripten::val value;
typedef struct _vkind *vkind;
typedef struct _buffer *buffer;
#define HAVE_NEKO_TYPES 1
#endif
#include "OS.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(BLACKBERRY)
using namespace std;
#endif
// --- Register functions (primitives) ----
#ifdef STATIC_LINK
#define DEFINE_PRIM_MULT(func) \
int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)); \
#define DEFINE_PRIM(func,nargs) \
int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)); \
#define DEFINE_PRIM_MULT_NATIVE(func,ext) \
int __reg_##func = hx_register_prim(#func "__MULT",(void *)(&func)) + \
hx_register_prim(#func "__" #ext,(void *)(&func##_##ext)) ;
#define DEFINE_PRIM_NATIVE(func,nargs,ext) \
int __reg_##func = hx_register_prim(#func "__" #nargs,(void *)(&func)) + \
hx_register_prim(#func "__" #ext,(void *)(&func##_##ext)) ;
#define DEFINE_LIB_PRIM_MULT(lib,func) \
int __reg_##func = hx_register_prim(lib "_" #func "__MULT",(void *)(&func)); \
#define DEFINE_LIB_PRIM(lib,func,nargs) \
int __reg_##func = hx_register_prim(lib "_" #func "__" #nargs,(void *)(&func)); \
#elif defined(HXCPP_JS_PRIME)
//#define DEFINE_PRIM_MULT(func) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
//TODO
#define DEFINE_PRIM_MULT(func)
#define DEFINE_PRIM(func,nargs) EMSCRIPTEN_BINDINGS(func) { function(#func, &func); }
#else
#define DEFINE_PRIM_MULT(func) extern "C" { \
EXPORT void *func##__MULT() { return (void*)(&func); } \
}
#define DEFINE_PRIM(func,nargs) extern "C" { \
EXPORT void *func##__##nargs() { return (void*)(&func); } \
}
#define DEFINE_PRIM_MULT_NATIVE(func,ext) extern "C" { \
EXPORT void *func##__MULT() { return (void*)(&func); } \
EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
}
#define DEFINE_PRIM_NATIVE(func,nargs,ext) extern "C" { \
EXPORT void *func##__##nargs() { return (void*)(&func); } \
EXPORT void *func##__##ext() { return (void*)(&func##_##ext); } \
}
#define DEFINE_LIB_PRIM_MULT(lib,func) extern "C" { \
EXPORT void *func##__MULT() { return (void*)(&func); } \
}
#define DEFINE_LIB_PRIM(lib,func,nargs) extern "C" { \
EXPORT void *func##__##nargs() { return (void*)(&func); } \
}
#endif // !STATIC_LINK
#define DEFFUNC_0(ret,name) DEFFUNC(name,ret, (), ())
#define DEFFUNC_1(ret,name,t1) DEFFUNC(name,ret, (t1 a1), (a1))
#define DEFFUNC_2(ret,name,t1,t2) DEFFUNC(name,ret, (t1 a1, t2 a2), (a1,a2))
#define DEFFUNC_3(ret,name,t1,t2,t3) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3), (a1,a2,a3))
#define DEFFUNC_4(ret,name,t1,t2,t3,t4) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4), (a1,a2,a3,a4))
#define DEFFUNC_5(ret,name,t1,t2,t3,t4,t5) DEFFUNC(name,ret, (t1 a1, t2 a2, t3 a3, t4 a4,t5 a5), (a1,a2,a3,a4,a5))
enum hxValueType
{
valtUnknown = -1,
valtInt = 0xff,
valtNull = 0,
valtFloat = 1,
valtBool = 2,
valtString = 3,
valtObject = 4,
valtArray = 5,
valtFunction = 6,
valtEnum,
valtClass,
valtRoot = 0xff,
valtAbstractBase = 0x100,
};
namespace hx
{
enum StringEncoding
{
StringAscii,
StringUtf8,
StringUtf16
};
}
// val_fun_nargs may return a special value
enum { faNotFunction = -2, faVarArgs=-1, faArgs0=0 /* ... */ };
typedef int field;
#ifdef IMPLEMENT_API
#include "CFFILoader.h"
#endif
#if !defined(HAVE_NEKO_TYPES)
#ifdef HXCPP_NATIVE_CFFI_VALUE
namespace hx { class Object; }
typedef hx::Object _value;
#else
struct _value;
#endif
typedef _value *value;
typedef struct _vkind *vkind;
typedef struct _buffer *buffer;
#endif
typedef buffer cffiByteBuffer;
typedef struct _gcroot *gcroot;
typedef void (*hxFinalizer)(value v);
typedef void (*hxPtrFinalizer)(void *v);
typedef void (__hx_field_iter)(value v,field f,void *);
#define hx_failure(msg) hx_fail(msg,__FILE__,__LINE__)
#ifndef IGNORE_CFFI_API_H
#ifndef IMPLEMENT_API
#if defined(STATIC_LINK) || defined(HXCPP_JS_PRIME)
#define DEFFUNC(name,ret,def_args,call_args) \
extern "C" ret name def_args;
#else
#define DEFFUNC(name,ret,def_args,call_args) \
typedef ret (*FUNC_##name) def_args; \
extern FUNC_##name name;
#endif
#endif
#include "CFFIAPI.h"
#ifdef WANT_DYNALLOC_ALLOC_BYTES
void *DynAlloc::allocBytes(size_t n)
{
return hx_alloc((int)n);
}
#endif
#define DEFINE_KIND(name) extern "C" { vkind name = 0; }
#ifdef STATIC_LINK
# define DEFINE_ENTRY_POINT(name)
#else
# define DEFINE_ENTRY_POINT(name) extern "C" { void name(); EXPORT void *__neko_entry_point() { return (void *)&name; } }
#endif
#ifdef HEADER_IMPORTS
# define H_EXTERN IMPORT
#else
# define H_EXTERN EXPORT
#endif
#define DECLARE_PRIM(func,nargs) extern "C" { H_EXTERN void *func##__##nargs(); }
#define DECLARE_KIND(name) extern "C" { H_EXTERN extern vkind name; }
// --- Helpers ----------------------------------------------------------------
// Check type...
inline bool val_is_null(value inVal) { return val_type(inVal)==valtNull; }
inline bool val_is_int(value inVal) { return val_type(inVal)==valtInt; }
inline bool val_is_bool(value inVal) { return val_type(inVal)==valtBool; }
inline bool val_is_float(value inVal) { return val_type(inVal)==valtFloat; }
inline bool val_is_string(value inVal) { return val_type(inVal)==valtString; }
inline bool val_is_function(value inVal) { return val_type(inVal)==valtFunction; }
inline bool val_is_array(value inVal) { return val_type(inVal)==valtArray; }
inline bool val_is_abstract(value inVal) { return val_type(inVal)>=valtAbstractBase; }
inline bool val_is_kind(value inVal,vkind inKind) { return val_to_kind(inVal,inKind)!=0; }
inline bool val_is_number(value inVal)
{
int t = val_type(inVal);
return t==valtInt || t==valtFloat;
}
inline bool val_is_object(value inVal)
{
int t = val_type(inVal);
return t==valtObject || t==valtEnum ||t==valtClass;
}
class AutoGCBlocking
{
public:
inline AutoGCBlocking(bool inSoftUnlock=false) :
mSoftUnlock(inSoftUnlock), mLocked( gc_try_blocking() ) { }
inline ~AutoGCBlocking() { Close(); }
inline void Close()
{
if (mLocked)
{
if (mSoftUnlock)
gc_try_unblocking();
else
gc_exit_blocking();
}
mLocked = false;
}
bool mLocked;
bool mSoftUnlock;
};
class AutoGCUnblocking
{
public:
AutoGCUnblocking() : mUnlocked( gc_try_unblocking() ) { }
~AutoGCUnblocking() { Close(); }
void Close() { if (mUnlocked) gc_enter_blocking(); mUnlocked = false; }
bool mUnlocked;
};
class AutoGCRoot
{
public:
AutoGCRoot(value inValue)
{
mRoot = 0;
mPtr = alloc_root();
if (mPtr)
*mPtr = inValue;
else
mRoot = create_root(inValue);
}
~AutoGCRoot()
{
if (mPtr)
free_root(mPtr);
else if (mRoot)
destroy_root(mRoot);
}
value get()const { return mPtr ? *mPtr : query_root(mRoot); }
void set(value inValue)
{
if (mPtr)
*mPtr = inValue;
else
{
if (mRoot) destroy_root(mRoot);
mRoot = create_root(inValue);
}
}
private:
value *mPtr;
gcroot mRoot;
AutoGCRoot(const AutoGCRoot &);
void operator=(const AutoGCRoot &);
};
struct CffiBytes
{
CffiBytes( unsigned char *inData=0, int inLength=0) : data(inData), length(inLength) {}
unsigned char *data;
int length;
};
inline CffiBytes getByteData(value inValue)
{
static field bField = 0;
static field lengthField = 0;
if (bField==0)
{
bField = val_id("b");
lengthField = val_id("length");
}
if (val_is_object(inValue))
{
value b = val_field(inValue, bField);
value len = val_field(inValue, lengthField);
if (val_is_string(b) && val_is_int(len))
return CffiBytes( (unsigned char *)val_string(b), val_int(len) );
if (val_is_buffer(b) && val_is_int(len))
return CffiBytes( (unsigned char *)buffer_data(val_to_buffer(b)), val_int(len) );
}
else if (val_is_buffer(inValue))
{
value len = val_field(inValue, lengthField);
if (val_is_int(len))
{
buffer b = val_to_buffer(inValue);
return CffiBytes( (unsigned char *)buffer_data(b), val_int(len) );
}
}
return CffiBytes();
}
inline bool resizeByteData(value inValue, int inNewLen)
{
if (!val_is_object(inValue))
return false;
static field bField = 0;
static field lengthField = 0;
if (bField==0)
{
bField = val_id("b");
lengthField = val_id("length");
}
value len = val_field(inValue, lengthField);
if (!val_is_int(len))
return false;
int oldLen = val_int(len);
value b = val_field(inValue, bField);
if (val_is_string(b))
{
if (inNewLen>oldLen)
{
value newString = alloc_raw_string(inNewLen);
memcpy( (char *)val_string(newString), val_string(b), inNewLen);
alloc_field(inValue, bField, newString );
}
alloc_field(inValue, lengthField, alloc_int(inNewLen) );
}
else if (val_is_buffer(b))
{
cffiByteBuffer buf = val_to_buffer(b);
buffer_set_size(buf,inNewLen);
alloc_field(inValue, lengthField, alloc_int(inNewLen) );
}
else
return false;
return true;
}
#define val_null alloc_null()
#define bfailure(x) val_throw(buffer_to_string(x))
#define copy_string(str,len) alloc_string_len(str,len)
// The "Check" macros throw an error if assumtion is false
#define val_check_kind(v,t) if( !val_is_kind(v,t) ) hx_failure("invalid kind");
#define val_check_function(f,n) if( !val_is_function(f) || (val_fun_nargs(f) != (n) && val_fun_nargs(f) != faVarArgs) ) hx_failure("Bad function");
#define val_check(v,t) if( !val_is_##t(v) ) hx_failure("type not " #t);
// The "Get" function will return or force an error
inline bool val_get_bool(value inVal) { val_check(inVal,bool); return val_bool(inVal); }
inline int val_get_int(value inVal) { val_check(inVal,int); return val_int(inVal); }
inline double val_get_double(value inVal) { val_check(inVal,number); return val_number(inVal); }
inline const char *val_get_string(value inVal) { val_check(inVal,string); return val_string(inVal); }
inline void *val_get_handle(value inVal,vkind inKind)
{ val_check_kind(inVal,inKind); return val_to_kind(inVal,inKind); }
inline value alloc_string(const char *inStr)
{
const char *end = inStr;
while(*end) end++;
return alloc_string_len(inStr,(int)(end-inStr));
}
inline value alloc_wstring(const wchar_t *inStr)
{
const wchar_t *end = inStr;
while(*end) end++;
return alloc_wstring_len(inStr,(int)(end-inStr));
}
inline void hxcpp_unscramble(const unsigned char *bytes, int len, const char *key, unsigned char *dest)
{
int keyLen = 0;
while(key[keyLen])
keyLen++;
int state = 0;
//state = ((state + key[i]) ^ ch) & 0xff);
for(int i=0;i<len;i++)
{
dest[i] = ( (state + key[i%keyLen]) ^ bytes[i] ) & 0xff;
state = bytes[i];
}
}
//additional glue for easier neko modules compilation
#define val_true alloc_bool(true)
#define val_false alloc_bool(false)
inline void neko_error() { hx_error(); }
// Conservative marking within a buffer is not yet supported.
//inline void * alloc(int i) { return hx_alloc(i); }
// The bytes themselves will be GC'd, but not the pointers contained within.
inline void * alloc_private(int i) { return hx_alloc(i); }
// You should use alloc_buffer_len/buffer_data instead
//value alloc_empty_string(int len) { }
#endif
#endif

189
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIAPI.h Normal file
View File

@ -0,0 +1,189 @@
/*
This bit of Macro magic is used to define extern function pointers
in ndlls, define stub implementations that link back to the hxcpp dll
and glue up the implementation in the hxcpp runtime.
*/
DEFFUNC_1(void,val_throw,value)
DEFFUNC_0(void,hx_error)
DEFFUNC_3(void,hx_fail,const char *,const char *,int)
// Determine value type
DEFFUNC_1(int,val_type,value)
DEFFUNC_1(vkind,val_kind,value)
DEFFUNC_2(void *,val_to_kind,value,vkind)
// don't check the 'kind' ...
DEFFUNC_1(void *,val_data,value)
DEFFUNC_1(int,val_fun_nargs,value)
// Extract value type
DEFFUNC_1(bool,val_bool,value)
DEFFUNC_1(int,val_int,value)
DEFFUNC_1(double,val_float,value)
DEFFUNC_1(double,val_number,value)
// Create value type
DEFFUNC_0(value,alloc_null)
DEFFUNC_1(value,alloc_bool,bool)
DEFFUNC_1(value,alloc_int,int)
DEFFUNC_1(value,alloc_float,double)
DEFFUNC_0(value,alloc_empty_object)
DEFFUNC_2(value,alloc_abstract,vkind,void *)
// Allocates conservative-collected memory
DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
DEFFUNC_1(void,free_abstract,value)
DEFFUNC_1(value,alloc_best_int,int)
DEFFUNC_1(value,alloc_int32,int)
// String access
DEFFUNC_1(int,val_strlen,value)
DEFFUNC_2(value,alloc_string_len,const char *,int)
DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
DEFFUNC_1(const wchar_t *,val_wstring,value)
DEFFUNC_1(const char *,val_string,value)
DEFFUNC_1(wchar_t *,val_dup_wstring,value)
DEFFUNC_1(char *,val_dup_string,value)
DEFFUNC_2(char *,alloc_string_data,const char *,int)
#ifdef HXCPP_PRIME
/*DEFFUNC_2(HxString,alloc_hxs_wchar,const wchar_t *,int)
DEFFUNC_2(HxString,alloc_hxs_utf16,const char16_t *,int)
DEFFUNC_2(HxString,alloc_hxs_utf8,const char *,int)*/
DEFFUNC_2(const char *,hxs_utf8,const HxString &,hx::IStringAlloc *)
DEFFUNC_2(const wchar_t *,hxs_wchar,const HxString &,hx::IStringAlloc *)
DEFFUNC_2(const char16_t *,hxs_utf16,const HxString &,hx::IStringAlloc *)
DEFFUNC_1(hx::StringEncoding,hxs_encoding,const HxString &)
#endif
// Array access - generic
DEFFUNC_1(value,alloc_array,int)
DEFFUNC_1(int,val_array_size,value)
DEFFUNC_2(void,val_array_set_size,value,int)
DEFFUNC_2(value,val_array_i,value,int)
DEFFUNC_3(void,val_array_set_i,value,int,value)
DEFFUNC_2(void,val_array_push,value,value)
// Array access - fast if possible - may return null
// Resizing the array may invalidate the pointer
DEFFUNC_1(bool *,val_array_bool,value)
DEFFUNC_1(int *,val_array_int,value)
DEFFUNC_1(double *,val_array_double,value)
DEFFUNC_1(float *,val_array_float,value)
DEFFUNC_1(value *,val_array_value,value)
// String Buffer
// A 'buffer' is a tool for joining strings together.
// The C++ implementation is haxe.io.BytesData
// The neko implementation is something else again, and can't be passes as a value, only copied to a string
// Create a buffer from string of an empty buffer of a given length
DEFFUNC_1(buffer,alloc_buffer,const char *)
DEFFUNC_1(buffer,alloc_buffer_len,int)
// Append a string representation of a value to the buffer
DEFFUNC_2(void,val_buffer,buffer,value)
// Append a c-string to a buffer
DEFFUNC_2(void,buffer_append,buffer,const char *)
// Append given number of bytes of a c-string to the buffer
DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
// Append given character to string
DEFFUNC_2(void,buffer_append_char,buffer,int)
// Convert buffer back into string value
DEFFUNC_1(value,buffer_to_string,buffer)
// These routines are for direct access to the c++ BytesData structure
// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
// This will never return true on a neko host.
DEFFUNC_1(bool,val_is_buffer,value)
// These functions are only valid if val_is_buffer returns true
// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
// Number of byes in the array
DEFFUNC_1(int,buffer_size,cffiByteBuffer)
// Pointer to the byte data - will become invalid if the array is resized
DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
// Convert c++ ByteBuffer back to 'value' - no copy involved
DEFFUNC_1(value,buffer_val,cffiByteBuffer)
// Resize the array - will invalidate the data
DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
// This is used by resizeByteData for manipulating bytes directly on neko
DEFFUNC_1(value,alloc_raw_string,int)
// Call Function
DEFFUNC_1(value,val_call0,value)
DEFFUNC_2(value,val_call1,value,value)
DEFFUNC_3(value,val_call2,value,value,value)
DEFFUNC_4(value,val_call3,value,value,value,value)
DEFFUNC_3(value,val_callN,value,value *,int)
// Call the function - catch and print any exceptions
DEFFUNC_1(value,val_call0_traceexcept,value)
// Call object field
DEFFUNC_2(value,val_ocall0,value,int)
DEFFUNC_3(value,val_ocall1,value,int,value)
DEFFUNC_4(value,val_ocall2,value,int,value,value)
DEFFUNC_4(value,val_ocallN,value,int,value *,int)
// Objects access
DEFFUNC_1(int,val_id,const char *)
DEFFUNC_3(void,alloc_field,value,int,value)
DEFFUNC_3(void,alloc_field_numeric,value,int,double)
DEFFUNC_2(value,val_field,value,int)
DEFFUNC_2(double,val_field_numeric,value,int)
DEFFUNC_1(value,val_field_name,field)
DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
// Abstract types
DEFFUNC_0(vkind,alloc_kind)
DEFFUNC_2(void,kind_share,vkind *,const char *)
// Garbage Collection
DEFFUNC_1(void *,hx_alloc,int)
DEFFUNC_2(void, val_gc,value,hxFinalizer)
DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
DEFFUNC_0(value *, alloc_root)
DEFFUNC_1(void, free_root,value *)
DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
// Only available on cpp target...
DEFFUNC_1(void, val_gc_add_root,value *)
DEFFUNC_1(void, val_gc_remove_root,value *)
// Only available on js target - use AutoGCRoot to assist
DEFFUNC_1(gcroot, create_root,value)
DEFFUNC_1(value, query_root,gcroot)
DEFFUNC_1(void, destroy_root,gcroot)
DEFFUNC_0(void, gc_enter_blocking)
DEFFUNC_0(void, gc_exit_blocking)
DEFFUNC_0(bool, gc_try_blocking)
DEFFUNC_0(void, gc_safe_point)
DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
DEFFUNC_0(bool, gc_try_unblocking)
// Used for finding functions in static libraries
DEFFUNC_2(int, hx_register_prim, const char *, void*)

202
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIJsPrime.h Normal file
View File

@ -0,0 +1,202 @@
extern "C"
{
typedef std::map<std::string,int> IdMap;
static IdMap sIdMap;
static std::vector<val> sIdKeys;
int val_id(const char *inName)
{
IdMap::iterator id = sIdMap.find(inName);
if (id==sIdMap.end())
{
int result = sIdMap.size();
sIdMap[inName] = result;
sIdKeys.push_back(value(inName));
return result;
}
return id->second;
}
double val_field_numeric(value inObject, int inFieldId)
{
return inObject[sIdKeys[inFieldId]].as<double>();
}
int val_int(value inValue) { return inValue.as<int>(); }
bool val_bool(value inValue) { return inValue.as<bool>(); }
double val_number(value inValue) { return inValue.as<double>(); }
double val_float(value inValue) { return inValue.as<double>(); }
value alloc_null() { return emscripten::val::null(); }
value alloc_int(int inValue) { return value(inValue); }
value alloc_best_int(int inValue) { return value(inValue); }
value alloc_int32(int inValue) { return value(inValue); }
value alloc_bool(bool inValue) { return value(inValue); }
value alloc_float(double inValue) { return value(inValue); }
value val_field(value inObject, int inIndex) { return inObject[sIdKeys[inIndex]]; }
void alloc_field(value inObject, int inIndex, value inValue) { inObject.set(sIdKeys[inIndex],inValue); }
/*
DEFFUNC_1(void,val_throw,value)
DEFFUNC_0(void,hx_error)
DEFFUNC_3(void,hx_fail,const char *,const char *,int)
// Determine value type
DEFFUNC_1(int,val_type,value)
DEFFUNC_1(vkind,val_kind,value)
DEFFUNC_2(void *,val_to_kind,value,vkind)
// don't check the 'kind' ...
DEFFUNC_1(void *,val_data,value)
DEFFUNC_1(int,val_fun_nargs,value)
// Create value type
DEFFUNC_0(value,alloc_empty_object)
DEFFUNC_2(value,alloc_abstract,vkind,void *)
// Allocates conservative-collected memory
DEFFUNC_3(value,create_abstract,vkind,int,hxFinalizer)
DEFFUNC_1(void,free_abstract,value)
// String access
DEFFUNC_1(int,val_strlen,value)
DEFFUNC_1(const wchar_t *,val_wstring,value)
DEFFUNC_1(const char *,val_string,value)
DEFFUNC_1(wchar_t *,val_dup_wstring,value)
DEFFUNC_1(char *,val_dup_string,value)
DEFFUNC_2(char *,alloc_string_data,const char *,int)
DEFFUNC_2(value,alloc_string_len,const char *,int)
DEFFUNC_2(value,alloc_wstring_len,const wchar_t *,int)
// Array access - generic
DEFFUNC_1(value,alloc_array,int)
DEFFUNC_1(int,val_array_size,value)
DEFFUNC_2(void,val_array_set_size,value,int)
DEFFUNC_2(value,val_array_i,value,int)
DEFFUNC_3(void,val_array_set_i,value,int,value)
DEFFUNC_2(void,val_array_push,value,value)
// Array access - fast if possible - may return null
// Resizing the array may invalidate the pointer
DEFFUNC_1(bool *,val_array_bool,value)
DEFFUNC_1(int *,val_array_int,value)
DEFFUNC_1(double *,val_array_double,value)
DEFFUNC_1(float *,val_array_float,value)
DEFFUNC_1(value *,val_array_value,value)
// String Buffer
// A 'buffer' is a tool for joining strings together.
// The C++ implementation is haxe.io.BytesData
// The neko implementation is something else again, and can't be passes as a value, only copied to a string
// Create a buffer from string of an empty buffer of a given length
DEFFUNC_1(buffer,alloc_buffer,const char *)
DEFFUNC_1(buffer,alloc_buffer_len,int)
// Append a string representation of a value to the buffer
DEFFUNC_2(void,val_buffer,buffer,value)
// Append a c-string to a buffer
DEFFUNC_2(void,buffer_append,buffer,const char *)
// Append given number of bytes of a c-string to the buffer
DEFFUNC_3(void,buffer_append_sub,buffer,const char *,int)
// Append given character to string
DEFFUNC_2(void,buffer_append_char,buffer,int)
// Convert buffer back into string value
DEFFUNC_1(value,buffer_to_string,buffer)
// These routines are for direct access to the c++ BytesData structure
// Use getByteData and resizeByteData for more generic access to haxe.io.Bytes
// This will never return true on a neko host.
DEFFUNC_1(bool,val_is_buffer,value)
// These functions are only valid if val_is_buffer returns true
// Currently, cffiByteBuffer is the same struct as buffer, but the usage is quite different
DEFFUNC_1(cffiByteBuffer,val_to_buffer,value)
// Number of byes in the array
DEFFUNC_1(int,buffer_size,cffiByteBuffer)
// Pointer to the byte data - will become invalid if the array is resized
DEFFUNC_1(char *,buffer_data,cffiByteBuffer)
// Convert c++ ByteBuffer back to 'value' - no copy involved
DEFFUNC_1(value,buffer_val,cffiByteBuffer)
// Resize the array - will invalidate the data
DEFFUNC_2(void,buffer_set_size,cffiByteBuffer,int)
// This is used by resizeByteData for manipulating bytes directly on neko
DEFFUNC_1(value,alloc_raw_string,int)
// Call Function
DEFFUNC_1(value,val_call0,value)
DEFFUNC_2(value,val_call1,value,value)
DEFFUNC_3(value,val_call2,value,value,value)
DEFFUNC_4(value,val_call3,value,value,value,value)
DEFFUNC_3(value,val_callN,value,value *,int)
// Call the function - catch and print any exceptions
DEFFUNC_1(value,val_call0_traceexcept,value)
// Call object field
DEFFUNC_2(value,val_ocall0,value,int)
DEFFUNC_3(value,val_ocall1,value,int,value)
DEFFUNC_4(value,val_ocall2,value,int,value,value)
DEFFUNC_4(value,val_ocallN,value,int,value *,int)
// Objects access
DEFFUNC_1(int,val_id,const char *)
DEFFUNC_3(void,alloc_field,value,int,value)
DEFFUNC_2(value,val_field,value,int)
DEFFUNC_2(double,val_field_numeric,value,int)
DEFFUNC_1(value,val_field_name,field)
DEFFUNC_3(void,val_iter_fields,value,__hx_field_iter,void *)
DEFFUNC_3(void,val_iter_field_vals,value,__hx_field_iter,void *)
// Abstract types
DEFFUNC_0(vkind,alloc_kind)
DEFFUNC_2(void,kind_share,vkind *,const char *)
// Garbage Collection
DEFFUNC_1(void *,hx_alloc,int)
DEFFUNC_2(void, val_gc,value,hxFinalizer)
DEFFUNC_2(void, val_gc_ptr,void *,hxPtrFinalizer)
DEFFUNC_0(value *, alloc_root)
DEFFUNC_1(void, free_root,value *)
DEFFUNC_2(void, gc_change_managed_memory,int,const char *)
// Only available on cpp target...
DEFFUNC_1(void, val_gc_add_root,value *)
DEFFUNC_1(void, val_gc_remove_root,value *)
// Only available on js target - use AutoGCRoot to assist
DEFFUNC_1(gcroot, create_root,value)
DEFFUNC_1(value, query_root,gcroot)
DEFFUNC_1(void, destroy_root,gcroot)
DEFFUNC_0(void, gc_enter_blocking)
DEFFUNC_0(void, gc_exit_blocking)
DEFFUNC_0(void, gc_safe_point)
DEFFUNC_2(void, gc_set_top_of_stack,int *,bool)
// Used for finding functions in static libraries
DEFFUNC_2(int, hx_register_prim, const char *, void*)
*/
}

330
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFILoader.h Normal file
View File

@ -0,0 +1,330 @@
#ifndef HX_CFFI_LOADER_H
#define HX_CFFI_LOADER_H
/*
This file will only be incuded in one cpp file in the ndll library -
the one with IMPLEMENT_API #defined.
The other files will refer to the val_ functions via the "extern" in CFFI.h
For dynamic linking, a macro (DEFFUNC) implements the "val_..." functions as function pointers,
and the cpp code calls these function pointers directly.
The pointers starts off as function pointers to bootstrap code, so when they are first called
the bootstrap uses the "ResolveProc" to find the correct version of the function for the particular
platform, and replaces the function pointer with this value. Subsequent calls then go directly
to the correct fucntion.
The ResolveProc can come from:
Explicitly setting - the proc is set when a dll is loaded into the hxcpp exe
Via 'GetProcAddress' on the exe - if symbols are needed and the proc has not been set
Internal implementation (CFFINekoLoader) - when linking agaist a neko process.
- Old code used to find this in NekoApi.dll, but the glue code is now built into each ndll directly.
For static linking, the functions are resolved at link time.
For HXCPP_JS_PRIME, these functions are implemented in CFFIJsPrime
*/
#ifdef ANDROID
#include <android/log.h>
#endif
#ifdef NEKO_WINDOWS
#include <windows.h>
#include <stdio.h>
// Stoopid windows ...
#ifdef RegisterClass
#undef RegisterClass
#endif
#ifdef abs
#undef abs
#endif
#else // NOT NEKO_WINDOWS
#ifdef NEKO_LINUX
#define EXT "dso"
#define NEKO_EXT "so"
//#define __USE_GNU 1
#elif defined(HX_MACOS)
#include <mach-o/dyld.h>
#define EXT "dylib"
#define NEKO_EXT "dylib"
#else
#if defined(EMSCRIPTEN)
#define EXT "ll"
#else
#define EXT "so"
#endif
#endif
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#endif
#if defined(BLACKBERRY)
using namespace std;
#endif
typedef void *(*ResolveProc)(const char *inName);
static ResolveProc sResolveProc = 0;
extern "C" {
EXPORT void hx_set_loader(ResolveProc inProc)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_INFO, "haxe plugin", "Got Load Proc %p", inProc );
#endif
sResolveProc = inProc;
}
}
#ifdef HXCPP_JS_PRIME // { js prime
#define DEFFUNC(name,ret,def_args,call_args) \
extern "C" ret name def_args;
#include "CFFIJsPrime.h"
#elif defined(STATIC_LINK) // js prime } { not js prime, static link
#define DEFFUNC(name,ret,def_args,call_args) \
extern "C" ret name def_args;
#else // static link } { Dynamic link
#ifdef NEKO_COMPATIBLE
#include "CFFINekoLoader.h"
#endif // NEKO_COMPATIBLE
// This code will get run when the library is compiled against a newer version of hxcpp,
// and the application code uses an older version.
bool default_val_is_buffer(void *inBuffer)
{
typedef void *(ValToBufferFunc)(void *);
static ValToBufferFunc *valToBuffer = 0;
if (!valToBuffer)
valToBuffer = (ValToBufferFunc *)sResolveProc("val_to_buffer");
if (valToBuffer)
return valToBuffer(inBuffer)!=0;
return false;
}
// Neko, old cpp and js_prime are all utf8 based - and go through here
#ifdef HXCPP_PRIME
struct DynAlloc : public hx::IStringAlloc
{
#define WANT_DYNALLOC_ALLOC_BYTES
void *allocBytes(size_t n);
};
HxString default_string_wchar(const wchar_t *src,int len)
{
hx::strbuf buf;
const char *str = cffi::to_utf8(src,len,&buf);
return HxString(str,len);
}
HxString default_string_utf8(const char *str,int len)
{
return HxString(str,len);
}
HxString default_string_utf16(const char16_t *src,int len)
{
hx::strbuf buf;
const char *str = cffi::to_utf8(src,len,&buf);
return HxString(str,len);
}
const char *default_to_utf8(const HxString &str,hx::IStringAlloc *alloc)
{
return str.c_str();
}
const wchar_t *default_to_wchar(const HxString &str,hx::IStringAlloc *alloc)
{
DynAlloc d;
if (!alloc)
alloc = &d;
return cffi::from_utf8<wchar_t>(str.c_str(),str.size(),alloc);
}
const char16_t *default_to_utf16(const HxString &str,hx::IStringAlloc *alloc)
{
DynAlloc d;
if (!alloc)
alloc = &d;
return cffi::from_utf8<char16_t>(str.c_str(),str.size(),alloc);
}
#endif
hx::StringEncoding default_get_encoding(void *inPtr) { return hx::StringUtf8; }
void * default_alloc_empty_string(int) { return 0; }
// Do nothing on earlier versions of hxcpp that do not know what to do
void default_gc_change_managed_memory(int,const char *) { }
void *ResolveDefault(const char *inName)
{
void *result = sResolveProc(inName);
if (result)
return result;
if (!strcmp(inName,"val_is_buffer"))
return (void *)default_val_is_buffer;
if (!strcmp(inName,"alloc_empty_string"))
return (void *)default_alloc_empty_string;
if (!strcmp(inName,"gc_change_managed_memory"))
return (void *)default_gc_change_managed_memory;
if (!strcmp(inName,"hxs_encoding"))
return (void *)default_get_encoding;
#ifdef HXCPP_PRIME
if (!strcmp(inName,"alloc_hxs_wchar"))
return (void *)default_string_wchar;
if (!strcmp(inName,"alloc_hxs_utf16"))
return (void *)default_string_utf16;
if (!strcmp(inName,"alloc_hxs_utf8"))
return (void *)default_string_utf8;
if (!strcmp(inName,"hxs_utf8"))
return (void *)default_to_utf8;
if (!strcmp(inName,"hxs_utf16"))
return (void *)default_to_utf16;
if (!strcmp(inName,"hxs_wchar"))
return (void *)default_to_wchar;
#endif
return 0;
}
#ifdef NEKO_WINDOWS // {
void *LoadFunc(const char *inName)
{
#ifndef HX_WINRT
static const char *modules[] = { 0, "hxcpp", "hxcpp-debug" };
for(int i=0; i<3 && sResolveProc==0; i++)
{
HMODULE handle = GetModuleHandleA(modules[i]);
if (handle)
{
sResolveProc = (ResolveProc)GetProcAddress(handle,"hx_cffi");
if (sResolveProc==0)
FreeLibrary(handle);
}
}
#endif
#ifdef NEKO_COMPATIBLE
if (sResolveProc==0)
{
sResolveProc = InitDynamicNekoLoader();
}
#endif
if (sResolveProc==0)
{
fprintf(stderr,"Could not link plugin to process (hxCFFILoader.h %d)\n",__LINE__);
exit(1);
}
return ResolveDefault(inName);
}
#else // windows } { not windows
void *LoadFunc(const char *inName)
{
#ifndef ANDROID // {
if (sResolveProc==0)
{
sResolveProc = (ResolveProc)dlsym(RTLD_DEFAULT,"hx_cffi");
}
#ifdef NEKO_COMPATIBLE
if (sResolveProc==0)
{
sResolveProc = InitDynamicNekoLoader();
}
#endif
#endif // !Android }
if (sResolveProc==0)
{
#ifdef ANDROID
__android_log_print(ANDROID_LOG_ERROR, "CFFILoader.h", "Could not API %s", inName);
return 0;
#else
#ifdef NEKO_COMPATIBLE
fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d) - with neko\n",__LINE__);
#else
fprintf(stderr,"Could not link plugin to process (CFFILoader.h %d)\n",__LINE__);
#endif
exit(1);
#endif
}
return ResolveDefault(inName);
}
#undef EXT
#endif // not windows }
#ifndef ANDROID // not android {
#define DEFFUNC(name,ret,def_args,call_args) \
typedef ret (*FUNC_##name)def_args; \
extern FUNC_##name name; \
ret IMPL_##name def_args \
{ \
name = (FUNC_##name)LoadFunc(#name); \
if (!name) \
{ \
fprintf(stderr,"Could not find function:" #name " \n"); \
exit(1); \
} \
return name call_args; \
}\
FUNC_##name name = IMPL_##name;
#ifdef NEKO_COMPATIBLE
DEFINE_PRIM(neko_init,5)
#endif
#else // not android } { android
#define DEFFUNC(name,ret,def_args,call_args) \
typedef ret (*FUNC_##name)def_args; \
extern FUNC_##name name; \
ret IMPL_##name def_args \
{ \
name = (FUNC_##name)LoadFunc(#name); \
if (!name) \
{ \
__android_log_print(ANDROID_LOG_ERROR,"CFFILoader", "Could not find function:" #name "\n"); \
} \
return name call_args; \
}\
FUNC_##name name = IMPL_##name;
#endif // android }
#endif // dynamic link }
#endif

723
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFINekoLoader.h Normal file
View File

@ -0,0 +1,723 @@
#ifndef HX_CFFI_NEKO_LOADER_H
#define HX_CFFI_NEKO_LOADER_H
//-------- NEKO Interface -----------------------------------------------------
namespace
{
#include <hx/NekoFunc.h>
void *sNekoDllHandle = 0;
void *LoadNekoFunc(const char *inName)
{
#ifdef HX_WINRT
return 0;
#else
static bool tried = false;
if (tried && !sNekoDllHandle)
return 0;
tried = true;
if (!sNekoDllHandle)
{
#ifdef HX_WINDOWS
sNekoDllHandle = GetModuleHandleA("neko.dll");
#else
sNekoDllHandle = dlopen("libneko." NEKO_EXT, RTLD_NOW);
// The debian package creates libneko.so.0 without libneko.so...
// The fedora/openSUSE rpm packages create libneko.so.1...
if (!sNekoDllHandle)
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".0", RTLD_NOW);
if (!sNekoDllHandle)
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".1", RTLD_NOW);
if (!sNekoDllHandle)
sNekoDllHandle = dlopen("libneko." NEKO_EXT ".2", RTLD_NOW);
#endif
if (!sNekoDllHandle)
{
fprintf(stderr,"Could not link to neko.\n");
return 0;
}
}
#ifdef HX_WINDOWS
void *result = (void *)GetProcAddress((HMODULE)sNekoDllHandle,inName);
#else
void *result = dlsym(sNekoDllHandle,inName);
#endif
//printf(" %s = %p\n", inName, result );
return result;
#endif // !HX_WINRT
}
static int __a_id = 0;
static int __s_id = 0;
static int b_id = 0;
static int length_id = 0;
static int push_id = 0;
neko_value *gNeko2HaxeString = 0;
neko_value *gNekoNewArray = 0;
neko_value gNekoNull = 0;
neko_value gNekoTrue = 0;
neko_value gNekoFalse = 0;
namespace
{
void CheckInitDynamicNekoLoader()
{
if (!gNekoNull)
{
printf("Haxe code is missing a call to cpp.Prime.nekoInit().\n");
}
}
}
/*
*/
void *DynamicNekoLoader(const char *inName);
typedef neko_value (*alloc_object_func)(neko_value);
typedef neko_value (*alloc_string_func)(const char *);
typedef neko_value (*alloc_abstract_func)(neko_vkind,void *);
typedef neko_value (*val_call1_func)(neko_value,neko_value);
typedef neko_value (*val_field_func)(neko_value,int);
typedef neko_value (*alloc_float_func)(double);
typedef void (*alloc_field_func)(neko_value,int,neko_value);
typedef neko_value *(*alloc_root_func)(int);
typedef char *(*alloc_private_func)(int);
typedef neko_value (*copy_string_func)(const char *,int);
typedef int (*val_id_func)(const char *);
typedef neko_buffer (*alloc_buffer_func)(const char *);
typedef neko_value (*val_buffer_func)(neko_buffer);
typedef void (*buffer_append_sub_func)(neko_buffer,const char *,int);
typedef void (*fail_func)(neko_value,const char *,int);
typedef neko_value (*alloc_array_func)(unsigned int);
typedef void (*val_gc_func)(neko_value,void *);
typedef void (*val_ocall1_func)(neko_value,int,neko_value);
typedef neko_value (*alloc_empty_string_func)(int);
static alloc_object_func dyn_alloc_object = 0;
static alloc_string_func dyn_alloc_string = 0;
static alloc_abstract_func dyn_alloc_abstract = 0;
static val_call1_func dyn_val_call1 = 0;
static val_field_func dyn_val_field = 0;
static alloc_field_func dyn_alloc_field = 0;
static alloc_float_func dyn_alloc_float = 0;
static alloc_root_func dyn_alloc_root = 0;
static alloc_private_func dyn_alloc_private = 0;
static alloc_private_func dyn_alloc = 0;
static copy_string_func dyn_copy_string = 0;
static val_id_func dyn_val_id = 0;
static alloc_buffer_func dyn_alloc_buffer = 0;
static val_buffer_func dyn_val_buffer = 0;
static fail_func dyn_fail = 0;
static buffer_append_sub_func dyn_buffer_append_sub = 0;
static alloc_array_func dyn_alloc_array = 0;
static val_gc_func dyn_val_gc = 0;
static val_ocall1_func dyn_val_ocall1 = 0;
static alloc_empty_string_func dyn_alloc_empty_string = 0;
neko_value api_alloc_string(const char *inString)
{
CheckInitDynamicNekoLoader();
neko_value neko_string = dyn_alloc_string(inString);
if (gNeko2HaxeString)
return dyn_val_call1(*gNeko2HaxeString,neko_string);
return neko_string;
}
char *api_alloc_string_data(const char *inString,int inLength)
{
CheckInitDynamicNekoLoader();
char *result = (char *)dyn_alloc_private(inLength+1);
memcpy(result,inString,inLength);
result[inLength]='\0';
return result;
}
neko_value api_alloc_raw_string(int inLength)
{
CheckInitDynamicNekoLoader();
return dyn_alloc_empty_string(inLength);
}
#define NEKO_NOT_IMPLEMENTED(func) dyn_fail(api_alloc_string("NOT Implemented:" func),__FILE__,__LINE__)
void * api_empty() { return 0; }
bool api_val_bool(neko_value arg1) { return arg1==gNekoTrue; }
int api_val_int(neko_value arg1) { return neko_val_int(arg1); }
double api_val_float(neko_value arg1) { return *(double *)( ((char *)arg1) + 4 ); }
double api_val_number(neko_value arg1) { return neko_val_is_int(arg1) ? neko_val_int(arg1) : api_val_float(arg1); }
neko_value api_alloc_bool(bool arg1) { CheckInitDynamicNekoLoader(); return arg1 ? gNekoTrue : gNekoFalse; }
neko_value api_alloc_int(int arg1) { return neko_alloc_int(arg1); }
neko_value api_alloc_empty_object()
{
return dyn_alloc_object(gNekoNull);
}
neko_value api_buffer_to_string(neko_buffer arg1)
{
neko_value neko_string = dyn_val_buffer(arg1);
if (gNeko2HaxeString)
return dyn_val_call1(*gNeko2HaxeString,neko_string);
return neko_string;
}
const char * api_val_string(neko_value arg1)
{
if (neko_val_is_string(arg1))
return neko_val_string(arg1);
if (neko_val_is_object(arg1))
{
neko_value s = dyn_val_field(arg1,__s_id);
if (neko_val_is_string(s))
return neko_val_string(s);
}
return 0;
}
void api_alloc_field_numeric(neko_value arg1,int arg2, double arg3)
{
dyn_alloc_field(arg1, arg2, dyn_alloc_float(arg3) );
}
double api_val_field_numeric(neko_value arg1,int arg2)
{
neko_value field = dyn_val_field(arg1, arg2);
if (neko_val_is_number(field))
return api_val_number(field);
if (field==gNekoTrue)
return 1;
return 0;
}
int api_val_strlen(neko_value arg1)
{
if (neko_val_is_string(arg1))
return neko_val_strlen(arg1);
if (neko_val_is_object(arg1))
{
neko_value l = dyn_val_field(arg1,length_id);
if (neko_val_is_int(l))
return api_val_int(l);
}
return 0;
}
void api_buffer_set_size(neko_buffer inBuffer,int inLen) {
NEKO_NOT_IMPLEMENTED("api_buffer_set_size");
}
void api_buffer_append_char(neko_buffer inBuffer,int inChar)
{
NEKO_NOT_IMPLEMENTED("api_buffer_append_char");
}
// Byte arrays - use strings
neko_buffer api_val_to_buffer(neko_value arg1)
{
return (neko_buffer)api_val_string(arg1);
}
bool api_val_is_buffer(neko_value arg1) { return neko_val_is_string(arg1); }
int api_buffer_size(neko_buffer inBuffer) { return neko_val_strlen((neko_value)inBuffer); }
char * api_buffer_data(neko_buffer inBuffer) { return (char *)api_val_string((neko_value)inBuffer); }
char * api_val_dup_string(neko_value inVal)
{
int len = api_val_strlen(inVal);
const char *ptr = api_val_string(inVal);
char *result = dyn_alloc_private(len+1);
memcpy(result,ptr,len);
result[len] = '\0';
return result;
}
neko_value api_alloc_string_len(const char *inStr,int inLen)
{
if (gNeko2HaxeString)
{
if (!inStr)
return dyn_val_call1(*gNeko2HaxeString,api_alloc_raw_string(inLen));
return dyn_val_call1(*gNeko2HaxeString,dyn_copy_string(inStr,inLen));
}
if (!inStr)
inStr = dyn_alloc_private(inLen);
return dyn_copy_string(inStr,inLen);
}
neko_buffer api_alloc_buffer_len(int inLen)
{
neko_value str=api_alloc_string_len(0,inLen+1);
char *s=(char *)api_val_string(str);
memset(s,0,inLen+1);
return (neko_buffer)str;
}
neko_value api_alloc_wstring_len(const wchar_t *inStr,int inLen)
{
int len = 0;
const wchar_t *chars = inStr;
for(int i=0;i<inLen;i++)
{
int c = chars[i];
if( c <= 0x7F ) len++;
else if( c <= 0x7FF ) len+=2;
else if( c <= 0xFFFF ) len+=3;
else len+= 4;
}
char *result = dyn_alloc_private(len);//+1?
unsigned char *data = (unsigned char *) &result[0];
for(int i=0;i<inLen;i++)
{
int c = chars[i];
if( c <= 0x7F )
*data++ = c;
else if( c <= 0x7FF )
{
*data++ = 0xC0 | (c >> 6);
*data++ = 0x80 | (c & 63);
}
else if( c <= 0xFFFF )
{
*data++ = 0xE0 | (c >> 12);
*data++ = 0x80 | ((c >> 6) & 63);
*data++ = 0x80 | (c & 63);
}
else
{
*data++ = 0xF0 | (c >> 18);
*data++ = 0x80 | ((c >> 12) & 63);
*data++ = 0x80 | ((c >> 6) & 63);
*data++ = 0x80 | (c & 63);
}
}
//result[len] = 0;
return api_alloc_string_len(result,len);
}
const wchar_t *api_val_wstring(neko_value arg1)
{
int len = api_val_strlen(arg1);
unsigned char *b = (unsigned char *)api_val_string(arg1);
wchar_t *result = (wchar_t *)dyn_alloc_private((len+1)*sizeof(wchar_t));
int l = 0;
for(int i=0;i<len;)
{
int c = b[i++];
if (c==0) break;
else if( c < 0x80 )
{
result[l++] = c;
}
else if( c < 0xE0 )
result[l++] = ( ((c & 0x3F) << 6) | (b[i++] & 0x7F) );
else if( c < 0xF0 )
{
int c2 = b[i++];
result[l++] = ( ((c & 0x1F) << 12) | ((c2 & 0x7F) << 6) | ( b[i++] & 0x7F) );
}
else
{
int c2 = b[i++];
int c3 = b[i++];
result[l++] = ( ((c & 0x0F) << 18) | ((c2 & 0x7F) << 12) | ((c3 << 6) & 0x7F) | (b[i++] & 0x7F) );
}
}
result[l] = '\0';
return result;
}
wchar_t * api_val_dup_wstring(neko_value inVal)
{
return (wchar_t *)api_val_wstring(inVal);
}
int api_val_type(neko_value arg1)
{
int t=neko_val_type(arg1);
if (t==VAL_OBJECT)
{
neko_value __a = dyn_val_field(arg1,__a_id);
if (neko_val_is_array(__a))
return valtArray;
neko_value __s = dyn_val_field(arg1,__s_id);
if (neko_val_is_string(__s))
return valtString;
}
if (t<7)
return (hxValueType)t;
if (t==VAL_ABSTRACT)
return valtAbstractBase;
if (t==VAL_PRIMITIVE || t==VAL_JITFUN)
return valtFunction;
if (t==VAL_32_BITS || t==VAL_INT)
return valtInt;
return valtNull;
}
neko_value *api_alloc_root()
{
return dyn_alloc_root(1);
}
void * api_val_to_kind(neko_value arg1,neko_vkind arg2)
{
neko_vkind k = (neko_vkind)neko_val_kind(arg1);
if (k!=arg2)
return 0;
return neko_val_data(arg1);
}
int api_alloc_kind()
{
static int id = 1;
int result = id;
id += 4;
return result;
}
neko_value api_alloc_null()
{
CheckInitDynamicNekoLoader();
return gNekoNull;
}
neko_value api_create_abstract(neko_vkind inKind,int inSize,void *inFinalizer)
{
void *data = dyn_alloc(inSize);
neko_value val = dyn_alloc_abstract(inKind, data);
dyn_val_gc(val, inFinalizer);
return val;
}
void api_free_abstract(neko_value inAbstract)
{
if (neko_val_is_abstract(inAbstract))
{
dyn_val_gc(inAbstract,0);
neko_val_kind(inAbstract) = 0;
}
}
neko_value api_buffer_val(neko_buffer arg1)
{
if (neko_val_is_string(arg1))
return (neko_value)arg1;
if (neko_val_is_object(arg1))
{
neko_value s = dyn_val_field((neko_value)arg1,__s_id);
if (neko_val_is_string(s))
return (neko_value)(s);
}
return api_alloc_null();
}
void api_hx_error()
{
dyn_fail(dyn_alloc_string("An unknown error has occurred."),"",1);
}
void * api_val_data(neko_value arg1) { return neko_val_data(arg1); }
// Array access - generic
int api_val_array_size(neko_value arg1)
{
if (neko_val_is_array(arg1))
return neko_val_array_size(arg1);
neko_value l = dyn_val_field(arg1,length_id);
return neko_val_int(l);
}
neko_value api_val_array_i(neko_value arg1,int arg2)
{
if (neko_val_is_array(arg1))
return neko_val_array_ptr(arg1)[arg2];
return neko_val_array_ptr(dyn_val_field(arg1,__a_id))[arg2];
}
void api_val_array_set_i(neko_value arg1,int arg2,neko_value inVal)
{
if (!neko_val_is_array(arg1))
arg1 = dyn_val_field(arg1,__a_id);
neko_val_array_ptr(arg1)[arg2] = inVal;
}
void api_val_array_set_size(neko_value arg1,int inLen)
{
NEKO_NOT_IMPLEMENTED("api_val_array_set_size");
}
void api_val_array_push(neko_value inArray,neko_value inValue)
{
dyn_val_ocall1(inArray,push_id,inValue);
}
neko_value api_alloc_array(int arg1)
{
if (!gNekoNewArray)
return dyn_alloc_array(arg1);
return dyn_val_call1(*gNekoNewArray,neko_alloc_int(arg1));
}
neko_value * api_val_array_value(neko_value arg1)
{
if (neko_val_is_array(arg1))
return neko_val_array_ptr(arg1);
return neko_val_array_ptr(dyn_val_field(arg1,__a_id));
}
neko_value api_val_call0_traceexcept(neko_value arg1)
{
NEKO_NOT_IMPLEMENTED("api_val_call0_traceexcept");
return gNekoNull;
}
int api_val_fun_nargs(neko_value arg1)
{
if (!arg1 || !neko_val_is_function(arg1) )
return faNotFunction;
return neko_val_fun_nargs(arg1);
}
void api_val_gc(neko_value obj, void *finalizer)
{
// Let neko deal with ints or abstracts ...
if (neko_val_is_int(obj) || neko_val_is_abstract(obj))
{
dyn_val_gc(obj,finalizer);
}
else
{
// Hack type to abstract for the duration
neko_val_type old_tag = neko_val_tag(obj);
neko_val_tag(obj) = VAL_ABSTRACT;
dyn_val_gc(obj,finalizer);
neko_val_tag(obj) = old_tag;
}
}
void api_gc_change_managed_memory(int,const char *)
{
// Nothing to do here
}
bool api_gc_try_blocking() { return false; }
bool api_gc_try_unblocking() { return false; }
#define IMPLEMENT_HERE(x) if (!strcmp(inName,#x)) return (void *)api_##x;
#define IGNORE_API(x) if (!strcmp(inName,#x)) return (void *)api_empty;
void *DynamicNekoLoader(const char *inName)
{
IMPLEMENT_HERE(alloc_kind)
IMPLEMENT_HERE(alloc_null)
IMPLEMENT_HERE(val_to_kind)
if (!strcmp(inName,"hx_fail"))
return LoadNekoFunc("_neko_failure");
IMPLEMENT_HERE(val_type)
IMPLEMENT_HERE(val_bool)
IMPLEMENT_HERE(val_int)
IMPLEMENT_HERE(val_float)
IMPLEMENT_HERE(val_number)
IMPLEMENT_HERE(val_field_numeric)
IMPLEMENT_HERE(alloc_bool)
IMPLEMENT_HERE(alloc_int)
IMPLEMENT_HERE(alloc_empty_object)
IMPLEMENT_HERE(alloc_root)
IMPLEMENT_HERE(val_gc)
IMPLEMENT_HERE(gc_try_blocking)
IMPLEMENT_HERE(gc_try_unblocking)
IMPLEMENT_HERE(create_abstract)
IMPLEMENT_HERE(free_abstract)
IGNORE_API(gc_enter_blocking)
IGNORE_API(gc_exit_blocking)
IGNORE_API(gc_safe_point)
IGNORE_API(gc_add_root)
IGNORE_API(gc_remove_root)
IGNORE_API(gc_set_top_of_stack)
IGNORE_API(gc_change_managed_memory)
IGNORE_API(create_root)
IGNORE_API(query_root)
IGNORE_API(destroy_root)
IGNORE_API(hx_register_prim)
IGNORE_API(val_array_int)
IGNORE_API(val_array_double)
IGNORE_API(val_array_float)
IGNORE_API(val_array_bool)
if (!strcmp(inName,"hx_alloc"))
return LoadNekoFunc("neko_alloc");
IMPLEMENT_HERE(buffer_to_string)
IMPLEMENT_HERE(buffer_val)
if (!strcmp(inName,"val_iter_field_vals"))
return LoadNekoFunc("neko_val_iter_fields");
IMPLEMENT_HERE(val_strlen)
IMPLEMENT_HERE(val_wstring)
IMPLEMENT_HERE(val_string)
IMPLEMENT_HERE(alloc_string)
IMPLEMENT_HERE(alloc_raw_string)
IMPLEMENT_HERE(alloc_string_data)
IMPLEMENT_HERE(val_dup_wstring)
IMPLEMENT_HERE(val_dup_string)
IMPLEMENT_HERE(alloc_string_len)
IMPLEMENT_HERE(alloc_wstring_len)
IMPLEMENT_HERE(val_is_buffer)
IMPLEMENT_HERE(val_to_buffer)
IMPLEMENT_HERE(alloc_buffer_len)
IMPLEMENT_HERE(buffer_size)
IMPLEMENT_HERE(buffer_set_size)
IMPLEMENT_HERE(buffer_append_char)
IMPLEMENT_HERE(buffer_data)
IMPLEMENT_HERE(hx_error)
IMPLEMENT_HERE(val_array_i)
IMPLEMENT_HERE(val_array_size)
IMPLEMENT_HERE(val_data)
IMPLEMENT_HERE(val_array_set_i)
IMPLEMENT_HERE(val_array_set_size)
IMPLEMENT_HERE(val_array_push)
IMPLEMENT_HERE(alloc_array)
IMPLEMENT_HERE(alloc_field_numeric)
IMPLEMENT_HERE(val_array_value)
IMPLEMENT_HERE(val_fun_nargs)
IMPLEMENT_HERE(val_call0_traceexcept)
char buffer[100];
strcpy(buffer,"neko_");
strcat(buffer,inName);
void *result = LoadNekoFunc(buffer);
if (result)
return result;
return 0;
}
ResolveProc InitDynamicNekoLoader()
{
static bool init = false;
if (!init)
{
dyn_alloc_private = (alloc_private_func)LoadNekoFunc("neko_alloc_private");
dyn_alloc = (alloc_private_func)LoadNekoFunc("neko_alloc");
dyn_alloc_object = (alloc_object_func)LoadNekoFunc("neko_alloc_object");
dyn_alloc_string = (alloc_string_func)LoadNekoFunc("neko_alloc_string");
dyn_alloc_abstract = (alloc_abstract_func)LoadNekoFunc("neko_alloc_abstract");
dyn_val_call1 = (val_call1_func)LoadNekoFunc("neko_val_call1");
dyn_val_field = (val_field_func)LoadNekoFunc("neko_val_field");
dyn_alloc_field = (alloc_field_func)LoadNekoFunc("neko_alloc_field");
dyn_alloc_float = (alloc_float_func)LoadNekoFunc("neko_alloc_float");
dyn_alloc_root = (alloc_root_func)LoadNekoFunc("neko_alloc_root");
dyn_copy_string = (copy_string_func)LoadNekoFunc("neko_copy_string");
dyn_val_id = (val_id_func)LoadNekoFunc("neko_val_id");
dyn_alloc_buffer = (alloc_buffer_func)LoadNekoFunc("neko_alloc_buffer");
dyn_val_buffer = (val_buffer_func)LoadNekoFunc("neko_buffer_to_string");
dyn_fail = (fail_func)LoadNekoFunc("_neko_failure");
dyn_buffer_append_sub = (buffer_append_sub_func)LoadNekoFunc("neko_buffer_append_sub");
dyn_alloc_array = (alloc_array_func)LoadNekoFunc("neko_alloc_array");
dyn_val_gc = (val_gc_func)LoadNekoFunc("neko_val_gc");
dyn_val_ocall1 = (val_ocall1_func)LoadNekoFunc("neko_val_ocall1");
dyn_alloc_empty_string = (alloc_empty_string_func)LoadNekoFunc("neko_alloc_empty_string");
init = true;
}
if (!dyn_val_id)
return 0;
__a_id = dyn_val_id("__a");
__s_id = dyn_val_id("__s");
b_id = dyn_val_id("b");
length_id = dyn_val_id("length");
push_id = dyn_val_id("push");
return DynamicNekoLoader;
}
neko_value neko_init(neko_value inNewString,neko_value inNewArray,neko_value inNull, neko_value inTrue, neko_value inFalse)
{
InitDynamicNekoLoader();
gNekoNull = inNull;
gNekoTrue = inTrue;
gNekoFalse = inFalse;
gNeko2HaxeString = dyn_alloc_root(1);
*gNeko2HaxeString = inNewString;
gNekoNewArray = dyn_alloc_root(1);
*gNekoNewArray = inNewArray;
return gNekoNull;
}
} // end anon namespace
#endif

1096
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/CFFIPrime.h Normal file
View File

File diff suppressed because it is too large Load Diff

307
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Class.h Normal file
View File

@ -0,0 +1,307 @@
#ifndef HX_CLASS_H
#define HX_CLASS_H
namespace hx
{
// --- hxClassOf --------------------------------------------------------------
//
// Gets the class definition that relates to a specific type.
// Most classes have their own class data, but the standard types (non-classes)
// use the template traits to get the class
template<typename T>
inline hx::Class &ClassOf() { typedef typename T::Obj Obj; return Obj::__SGetClass(); }
template<>
inline hx::Class &ClassOf<int>() { return GetIntClass(); }
template<>
inline hx::Class &ClassOf<double>() { return GetFloatClass(); }
template<>
inline hx::Class &ClassOf<float>() { return GetFloatClass(); }
template<>
inline hx::Class &ClassOf<bool>() { return GetBoolClass(); }
template<>
inline hx::Class &ClassOf<null>() { return GetVoidClass(); }
template<>
inline hx::Class &ClassOf<String>() { return GetStringClass(); }
template<>
inline hx::Class &ClassOf< ::cpp::Int64>() { return GetInt64Class(); }
template<typename T>
struct hxBaseType { typedef T type; };
template<typename T>
struct hxBaseType< hx::ObjectPtr<T> > { typedef T type; };
template<typename T> inline int ClassSizeOf() { return sizeof( typename hx::hxBaseType<T>::type ); }
} // end namespace hx
// --- Class_obj --------------------------------------------------------------------
//
// The Class_obj provides the type information required by the Reflect and type APIs.
namespace hx
{
typedef Dynamic (*ConstructEmptyFunc)();
typedef Dynamic (*ConstructArgsFunc)(DynamicArray inArgs);
typedef Dynamic (*ConstructEnumFunc)(String inName,DynamicArray inArgs);
typedef void (*MarkFunc)(hx::MarkContext *__inCtx);
typedef bool (*CanCastFunc)(hx::Object *inPtr);
#ifdef HXCPP_VISIT_ALLOCS
typedef void (*VisitFunc)(hx::VisitContext *__inCtx);
#endif
typedef bool (*GetStaticFieldFunc)(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
typedef bool (*SetStaticFieldFunc)(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
}
inline bool operator!=(hx::ConstructEnumFunc inFunc,const null &inNull) { return inFunc!=0; }
#ifdef HXCPP_SCRIPTABLE
namespace hx
{
enum FieldStorage
{
fsUnknown = 0,
fsBool,
fsInt,
fsFloat,
fsString,
fsByte,
fsObject,
};
struct StorageInfo
{
FieldStorage type;
int offset;
String name;
};
struct StaticInfo
{
FieldStorage type;
void *address;
String name;
};
}
#endif
namespace hx
{
class HXCPP_EXTERN_CLASS_ATTRIBUTES Class_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClass };
inline void *operator new( size_t inSize )
{
return hx::InternalCreateConstBuffer(0,(int)inSize);
}
void operator delete( void *) { }
Class_obj() : mSuper(0) { };
Class_obj(const String &inClassName, String inStatics[], String inMembers[],
hx::ConstructEmptyFunc inConstructEmpty, hx::ConstructArgsFunc inConstructArgs,
hx::Class *inSuperClass, hx::ConstructEnumFunc inConstructEnum,
hx::CanCastFunc inCanCast, hx::MarkFunc inMarkFunc
#ifdef HXCPP_VISIT_ALLOCS
, hx::VisitFunc inVisitFunc
#endif
#ifdef HXCPP_SCRIPTABLE
,const hx::StorageInfo *inStorageInfo
,const hx::StaticInfo *inStaticInfo
#endif
);
String __ToString() const;
void MarkStatics(hx::MarkContext *__inCtx);
#ifdef HXCPP_VISIT_ALLOCS
void VisitStatics(hx::VisitContext *__inCtx);
#endif
static ::Array< ::String > dupFunctions(String inStatics[]);
// the "Class class"
hx::Class __GetClass() const;
static hx::Class & __SGetClass();
static void __boot();
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
bool __HasField(const String &inString);
virtual Dynamic ConstructEmpty();
virtual Dynamic ConstructArgs(hx::DynamicArray inArgs);
virtual Dynamic ConstructEnum(String inName,hx::DynamicArray inArgs);
virtual bool VCanCast(hx::Object *inPtr) { return false; }
int __GetType() const { return vtObject; }
virtual bool __IsEnum();
inline bool CanCast(hx::Object *inPtr) { return mCanCast ? mCanCast(inPtr) : VCanCast(inPtr); }
static bool GetNoStaticField(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool SetNoStaticField(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
void registerScriptable(bool inOverwrite);
hx::CanCastFunc mCanCast;
virtual Array<String> GetInstanceFields();
virtual Array<String> GetClassFields();
hx::Class GetSuper();
#ifdef HXCPP_SCRIPTABLE
const hx::StorageInfo* GetMemberStorage(String inName);
const hx::StaticInfo* GetStaticStorage(String inName);
#endif
static hx::Class Resolve(String inName);
hx::Class *mSuper;
String mName;
Dynamic __meta__;
String __rtti__;
hx::ConstructArgsFunc mConstructArgs;
hx::ConstructEmptyFunc mConstructEmpty;
hx::ConstructEnumFunc mConstructEnum;
hx::GetStaticFieldFunc mGetStaticField;
hx::SetStaticFieldFunc mSetStaticField;
hx::MarkFunc mMarkFunc;
#ifdef HXCPP_VISIT_ALLOCS
hx::VisitFunc mVisitFunc;
#endif
Array<String> mStatics;
Array<String> mMembers;
#ifdef HXCPP_SCRIPTABLE
const hx::StorageInfo* mMemberStorageInfo;
const hx::StaticInfo* mStaticStorageInfo;
#endif
};
} // end namespace hx
void __hxcpp_boot_std_classes();
// --- All classes should be registered with this function via the "__boot" method
#ifdef RegisterClass
#undef RegisterClass
#endif
namespace hx
{
HXCPP_EXTERN_CLASS_ATTRIBUTES
hx::Class _hx_RegisterClass(const String &inClassName, CanCastFunc inCanCast,
String inStatics[], String inMembers[],
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
#ifdef HXCPP_VISIT_ALLOCS
, VisitFunc inVisitFunc=0
#endif
#ifdef HXCPP_SCRIPTABLE
,const hx::StorageInfo *inStorageInfo=0
,const hx::StaticInfo *inStaticInfo=0
#endif
);
// For older versions
inline hx::Class RegisterClass(
const String &inClassName, CanCastFunc inCanCast,
String inStatics[], String inMembers[],
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
#ifdef HXCPP_VISIT_ALLOCS
, VisitFunc inVisitFunc=0
#endif
#ifdef HXCPP_SCRIPTABLE
,const hx::StorageInfo *inStorageInfo=0
,const hx::StaticInfo *inStaticInfo=0
#endif
)
{
return _hx_RegisterClass(inClassName, inCanCast, inStatics, inMembers,
inConstructEmpty, inConstructArgs, inSuperClass, inConst, inMarkFunc
#ifdef HXCPP_VISIT_ALLOCS
, inVisitFunc
#endif
#ifdef HXCPP_SCRIPTABLE
,inStorageInfo ,inStaticInfo
#endif
);
}
HXCPP_EXTERN_CLASS_ATTRIBUTES
void _hx_RegisterClass(const String &inClassName, hx::Class inClass);
inline void RegisterClass(const String &inClassName, hx::Class inClass)
{
_hx_RegisterClass(inClassName, inClass);
}
template<typename T>
inline bool TCanCast(hx::Object *inPtr)
{
return inPtr && (
#if (HXCPP_API_LEVEL >= 332)
inPtr->_hx_isInstanceOf(T::_hx_ClassId)
#elif (HXCPP_API_LEVEL==331)
dynamic_cast<T *>(inPtr)
#else
dynamic_cast<T *>(inPtr->__GetRealObject())
#if (HXCPP_API_LEVEL < 330)
|| inPtr->__ToInterface(typeid(T))
#endif
#endif
);
}
#if (HXCPP_API_LEVEL >= 330)
template<int HASH>
inline bool TIsInterface(hx::Object *inPtr)
{
return inPtr && inPtr->_hx_getInterface(HASH);
}
#endif
HXCPP_EXTERN_CLASS_ATTRIBUTES void RegisterVTableOffset(int inOffset);
#define HX_REGISTER_VTABLE_OFFSET( CLASS, INTERFACE ) \
{ \
CLASS *dummy = (CLASS *)0; \
INTERFACE *intf = dummy; \
hx::RegisterVTableOffset( (int)( (size_t)((char *)intf - (char *)dummy)) ); \
}
}
#endif

365
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Debug.h Normal file
View File

@ -0,0 +1,365 @@
#ifndef HX_DEBUG_H
#define HX_DEBUG_H
#include <hxcpp.h>
// Some functions used by AdvancedDebug.cpp
// Returns the thread number of the calling thread
HXCPP_EXTERN_CLASS_ATTRIBUTES
int __hxcpp_GetCurrentThreadNumber();
namespace hx
{
#ifdef HXCPP_DEBUGGER
template<typename T> struct StackVariableWrapper
{
typedef T wrapper;
};
template<> struct StackVariableWrapper<size_t>
{
#ifdef HXCPP_M64
typedef cpp::Int64 wrapper;
#else
typedef int wrapper;
#endif
};
template<typename T> struct StackVariableWrapper<T *>
{
typedef cpp::Pointer<T> wrapper;
};
class StackVariable
{
public:
const char *mHaxeName;
bool mIsArg;
StackVariable *mNext;
template<typename T>
StackVariable(StackVariable *&inHead, bool inIsArg,
const char *inHaxeName, T *inCppVar)
: mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
mCppVar((void *) inCppVar)
{
mGetOrSetFunction = GetOrSetFunction<T>;
mNext = mHead;
mHead = this;
}
StackVariable(StackVariable *&inHead, bool inIsArg,
const char *inHaxeName, hx::Object **inCppVar)
: mHaxeName(inHaxeName), mIsArg(inIsArg), mHead(inHead),
mCppVar((void *) inCppVar)
{
mGetOrSetFunction = GetOrSetFunctionHxObject;
mNext = mHead;
mHead = this;
}
// For StackThis
template<typename T>
StackVariable(StackVariable *&inHead, T *inCppVar)
: mHaxeName("this"), mIsArg(true), mHead(inHead),
mCppVar((void *) inCppVar)
{
mNext = mHead;
mHead = this;
}
~StackVariable()
{
// Stack variables are always deleted in the reverse order that they
// are created, so a simple pop_front is sufficient; no need to hunt
// for and remove the variable, it's always in the front ...
mHead = mNext;
}
operator Dynamic()
{
return mGetOrSetFunction(true, mCppVar, 0);
}
StackVariable &operator =(Dynamic &other)
{
(void) mGetOrSetFunction(false, mCppVar, &other);
return *this;
}
protected:
typedef Dynamic (*GetOrSetFunctionType)(bool, void *, Dynamic *);
GetOrSetFunctionType mGetOrSetFunction;
private:
template<typename T>
static Dynamic GetOrSetFunction(bool get, void *ptr, Dynamic *dynamic)
{
typedef typename StackVariableWrapper<T>::wrapper Wrap;
if (get) {
return Wrap(* (T *) ptr);
}
else {
* (T *) ptr = Wrap(*dynamic);
return null();
}
}
static Dynamic GetOrSetFunctionHxObject(bool get, void *ptr, Dynamic *dynamic)
{
if (get) {
return * (hx::Object **) ptr;
}
else {
* (hx::Object **)ptr = dynamic->mPtr;
return null();
}
}
StackVariable *&mHead;
void *mCppVar;
};
class StackThis : public StackVariable
{
public:
template<typename T>
StackThis(StackVariable *&inHead, T *inThis)
: StackVariable(inHead, inThis)
{
mGetOrSetFunction = GetFunction<T>;
}
template<typename T>
StackThis(StackVariable *&inHead, hx::ObjectPtr<T> &inThis)
: StackVariable(inHead, &inThis.mPtr)
{
mGetOrSetFunction = GetObjectPtr<T>;
}
template<typename T>
static Dynamic GetObjectPtr(bool get, void *ptr, Dynamic *val)
{
if (get) {
return *(hx::Object **) ptr;
}
else {
return null();
}
}
template<typename T>
static Dynamic GetFunction(bool get, void *ptr, Dynamic *val)
{
if (get) {
return (T *) ptr;
}
else {
return null();
}
}
};
class StackCatchable
{
public:
StackCatchable *mNext;
template<typename T>
StackCatchable(StackFrame &frame, T * /* dummy required by template*/)
: mFrame(frame)
{
mNext = frame.catchables;
frame.catchables = this;
mTestFunction = TestFunction<T>;
}
~StackCatchable()
{
mFrame.catchables = mNext;
}
bool Catches(Dynamic e) const
{
return mTestFunction(e);
}
private:
template<typename T>
static bool TestFunction(Dynamic e)
{
return e.IsClass<T>();
}
StackFrame &mFrame;
bool (*mTestFunction)(Dynamic e);
};
#endif // HXCPP_DEBUGGER
} // end namespace hx
void __hxcpp_dbg_getScriptableFiles( Array< ::String> ioPaths );
void __hxcpp_dbg_getScriptableFilesFullPath( Array< ::String> ioPaths );
void __hxcpp_dbg_getScriptableClasses( Array< ::String> ioClasses );
#ifdef HXCPP_DEBUGGER
namespace hx
{
// These must match the values present in cpp.vm.Debugger
enum ThreadEvent
{
THREAD_CREATED = 1,
THREAD_TERMINATED = 2,
THREAD_STARTED = 3,
THREAD_STOPPED = 4
};
enum StepType
{
STEP_NONE = 0, // Not present or needed in cpp.vm.Debugger
STEP_INTO = 1,
STEP_OVER = 2,
STEP_OUT = 3
};
} // end namespace hx
// The following functions are called directly, and only, by the haxe standard
// library's cpp.vm.Debugger.hx class
void __hxcpp_dbg_setEventNotificationHandler(Dynamic handler);
void __hxcpp_dbg_enableCurrentThreadDebugging(bool enable);
int __hxcpp_dbg_getCurrentThreadNumber();
Array< ::String> __hxcpp_dbg_getFiles();
Array< ::String> __hxcpp_dbg_getFilesFullPath();
Array< ::String> __hxcpp_dbg_getClasses();
Array<Dynamic> __hxcpp_dbg_getThreadInfos();
Dynamic __hxcpp_dbg_getThreadInfo(int threadNumber, bool unsafe);
int __hxcpp_dbg_addFileLineBreakpoint(String fileName, int lineNumber);
int __hxcpp_dbg_addClassFunctionBreakpoint(String className,
String functionName);
void __hxcpp_dbg_deleteAllBreakpoints();
void __hxcpp_dbg_deleteBreakpoint(int number);
void __hxcpp_dbg_breakNow(bool wait);
void __hxcpp_dbg_continueThreads(int threadNumber, int count);
void __hxcpp_dbg_stepThread(int threadNumber, int stepType, int stepCount);
Array<Dynamic> __hxcpp_dbg_getStackVariables(int threadNumber,
int stackFrameNumber,
bool unsafe,
Dynamic markThreadNotStopped);
Dynamic __hxcpp_dbg_getStackVariableValue(int threadNumber,
int stackFrameNumber,
String name,
bool unsafe,
Dynamic markNonexistent,
Dynamic markThreadNotStopped);
Dynamic __hxcpp_dbg_setStackVariableValue(int threadNumber,
int stackFrameNumber,
String name, Dynamic value,
bool unsafe,
Dynamic markNonexistent,
Dynamic markThreadNotStopped);
void __hxcpp_dbg_setNewParameterFunction(Dynamic function);
void __hxcpp_dbg_setNewStackFrameFunction(Dynamic function);
void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic function);
void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic function);
void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic function);
bool __hxcpp_dbg_fix_critical_error(String inErr);
// The following functions are called by Thread.cpp to notify of thread
// created and terminated
void __hxcpp_dbg_threadCreatedOrTerminated(int threadNumber, bool created);
// The following is called by the stack macros, but only if
// HXCPP_DEBUGGER is set
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow);
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow);
#else // !HXCPP_DEBUGGER
// If no debugger, provide empty implementations of the debugging functions
inline void __hxcpp_dbg_setEventNotificationHandler(Dynamic)
{ hx::Throw("Debugging is not enabled for this program; try\n"
"rebuilding it with the -D HXCPP_DEBUGGER option"); }
inline void __hxcpp_dbg_enableCurrentThreadDebugging(bool) { }
inline int __hxcpp_dbg_getCurrentThreadNumber() { return -1; }
inline Array< ::String> __hxcpp_dbg_getFiles()
{ return Array_obj< String>::__new(); }
inline Array< ::String> __hxcpp_dbg_getFilesFullPath()
{ return Array_obj< String>::__new(); }
inline Array< ::String> __hxcpp_dbg_getClasses()
{ return Array_obj< String>::__new(); }
inline Array<Dynamic> __hxcpp_dbg_getThreadInfos()
{ return Array_obj< ::Dynamic>::__new(); }
inline Dynamic __hxcpp_dbg_getThreadInfo(int, bool) { return null(); }
inline int __hxcpp_dbg_addFileLineBreakpoint(String, int) { return -1; }
inline int __hxcpp_dbg_addClassFunctionBreakpoint(String, String)
{ return -1; }
inline void __hxcpp_dbg_deleteAllBreakpoints() { }
inline void __hxcpp_dbg_deleteBreakpoint(int) { }
inline void __hxcpp_dbg_breakNow(bool) { }
inline void __hxcpp_dbg_continueThreads(int, int) { }
inline void __hxcpp_dbg_stepThread(int, int, int) { }
inline Array<Dynamic> __hxcpp_dbg_getStackVariables(int, int, bool, Dynamic)
{ return Array_obj< String>::__new(); }
inline Dynamic __hxcpp_dbg_getStackVariableValue(int, int, String, bool,
Dynamic, Dynamic)
{ return null(); }
inline Dynamic __hxcpp_dbg_setStackVariableValue(int, int, String, Dynamic,
bool, Dynamic, Dynamic)
{ return null(); }
inline void __hxcpp_dbg_setNewParameterFunction(Dynamic) { }
inline void __hxcpp_dbg_setNewStackFrameFunction(Dynamic) { }
inline void __hxcpp_dbg_setNewThreadInfoFunction(Dynamic) { }
inline void __hxcpp_dbg_setAddParameterToStackFrameFunction(Dynamic) { }
inline void __hxcpp_dbg_setAddStackFrameToThreadInfoFunction(Dynamic) { }
// The following functions are called by Thread.cpp to notify of thread
// created and terminated
inline void __hxcpp_dbg_threadCreatedOrTerminated(int, bool) { }
inline Dynamic __hxcpp_dbg_checkedThrow(Dynamic toThrow) { return hx::Throw(toThrow); }
inline Dynamic __hxcpp_dbg_checkedRethrow(Dynamic toThrow) { return hx::Rethrow(toThrow); }
#endif // HXCPP_DEBUGGER
#endif // HX_DEBUG_H

1095
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.h Normal file
View File

File diff suppressed because it is too large Load Diff

210
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/DynamicImpl.tpl Normal file
View File

@ -0,0 +1,210 @@
::foreach PARAMS:: ::if (ARG>=6)::
Dynamic Dynamic::NS::operator()(::DYNAMIC_ARG_LIST::)
{
CheckFPtr();
return mPtr->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
}
namespace cpp
{
::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::)
{
if (isNull()) Dynamic::ThrowBadFunctionError();
return valObject->__Run(Array_obj<Dynamic>::NS::__new(::ARG::)::DYNAMIC_ADDS::);
}
}
::else::
namespace hx {
struct CMemberFunction::ARG:: : public hx::Object
{
hx::ObjectPtr<Object> mThis;
MemberFunction::ARG:: mFunction;
const char *mName;
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCMember::ARG:: };
CMemberFunction::ARG::(const char *inName, hx::Object *inObj, MemberFunction::ARG:: inFunction)
{
mName = inName;
mThis = inObj;
mFunction = inFunction;
}
int __Compare(const hx::Object *inRHS) const
{
const CMemberFunction::ARG:: *other = dynamic_cast<const CMemberFunction::ARG:: *>(inRHS);
if (!other)
return -1;
return (mName==other->mName && mFunction==other->mFunction && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
}
int __GetType() const { return vtFunction; }
int __ArgCount() const { return ::ARG::; }
::String __ToString() const{ return String(mName); }
void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunction::ARG::.this"); }
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); }
#endif
void *__GetHandle() const { return mThis.GetPtr(); }
Dynamic __Run(const Array<Dynamic> &inArgs)
{
::if (ARG>0)::
return mFunction(mThis.GetPtr(), ::ARR_LIST::);
::else::
return mFunction(mThis.GetPtr());
::end::
}
Dynamic __run(::DYNAMIC_ARG_LIST::)
{
::if (ARG>0)::
return mFunction(mThis.GetPtr(), ::ARG_LIST::);
::else::
return mFunction(mThis.GetPtr());
::end::
}
};
struct CStaticFunction::ARG:: : public hx::Object
{
StaticFunction::ARG:: mFunction;
const char *mName;
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::NS::clsIdCStatic::ARG:: };
CStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunction)
{
mName = inName;
mFunction = inFunction;
}
int __Compare(const hx::Object *inRHS) const
{
const CStaticFunction::ARG:: *other = dynamic_cast<const CStaticFunction::ARG:: *>(inRHS);
if (!other)
return -1;
return mName==other->mName && mFunction==other->mFunction && mName==other->mName ? 0 : -1;
}
int __GetType() const { return vtFunction; }
int __ArgCount() const { return ::ARG::; }
::String __ToString() const{ return String(mName); }
Dynamic __Run(const Array<Dynamic> &inArgs)
{
return mFunction(::ARR_LIST::);
}
Dynamic __run(::DYNAMIC_ARG_LIST::)
{
return mFunction(::ARG_LIST::);
}
};
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateMemberFunction::ARG::(const char *inName,hx::Object *inObj, MemberFunction::ARG:: inFunc)
{ return new CMemberFunction::ARG::(inName,inObj,inFunc); }
HXCPP_EXTERN_CLASS_ATTRIBUTES
Dynamic CreateStaticFunction::ARG::(const char *inName,StaticFunction::ARG:: inFunc)
{ return new CStaticFunction::ARG::(inName,inFunc); }
}
::end::
::end::
namespace hx
{
struct CMemberFunctionVar : public hx::Object
{
hx::ObjectPtr<Object> mThis;
MemberFunctionVar mFunction;
const char *mName;
int N;
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCMemberVar };
CMemberFunctionVar(const char *inName,hx::Object *inObj, MemberFunctionVar inFunction,int inN)
{
mThis = inObj;
mFunction = inFunction;
mName = inName;
N = inN;
}
int __Compare(const hx::Object *inRHS) const
{
const CMemberFunctionVar *other = dynamic_cast<const CMemberFunctionVar *>(inRHS);
if (!other)
return -1;
return (mFunction==other->mFunction && mName==other->mName && mThis.GetPtr()==other->mThis.GetPtr())? 0 : -1;
}
int __GetType() const { return vtFunction; }
int __ArgCount() const { return N; }
::String __ToString() const{ return String(mName); }
void __Mark(hx::MarkContext *__inCtx) { HX_MARK_MEMBER_NAME(mThis,"CMemberFunctionVar.this"); }
#ifdef HXCPP_VISIT_ALLOCS
void __Visit(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(mThis); }
#endif
void *__GetHandle() const { return mThis.GetPtr(); }
Dynamic __Run(const Array<Dynamic> &inArgs)
{
return mFunction(mThis.GetPtr(), inArgs);
}
};
struct CStaticFunctionVar : public hx::Object
{
StaticFunctionVar mFunction;
const char *mName;
int N;
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdCStaticVar };
CStaticFunctionVar(const char *inName,StaticFunctionVar inFunction,int inN)
{
mFunction = inFunction;
mName = inName;
N = inN;
}
int __Compare(const hx::Object *inRHS) const
{
const CStaticFunctionVar *other = dynamic_cast<const CStaticFunctionVar *>(inRHS);
if (!other)
return -1;
return mName==other->mName && mFunction==other->mFunction ? 0 : -1;
}
int __GetType() const { return vtFunction; }
int __ArgCount() const { return N; }
::String __ToString() const { return String(mName); }
Dynamic __Run(const Array<Dynamic> &inArgs)
{
return mFunction(inArgs);
}
};
Dynamic CreateMemberFunctionVar(const char *inName, hx::Object *inObj, MemberFunctionVar inFunc,int inN)
{ return new CMemberFunctionVar(inName, inObj,inFunc,inN); }
Dynamic CreateStaticFunctionVar(const char *inName,StaticFunctionVar inFunc,int inN)
{ return new CStaticFunctionVar(inName, inFunc,inN); }
}

27
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ErrorCodes.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef HX_ERROR_CODES
#define HX_ERROR_CODES
// --- Exteral constants, used inline
#define HX_INVALID_CAST Dynamic(HX_CSTRING("Invalid Cast"))
#define HX_INVALID_INTERFACE Dynamic(HX_CSTRING("Object does not implement interface"))
#define HX_INDEX_OUT_OF_BOUNDS Dynamic(HX_CSTRING("Index Out of Bounds"))
#define HX_INVALID_CONSTRUCTOR Dynamic(HX_CSTRING("Invalid constructor"))
#define HX_INVALID_ENUM_CONSTRUCTOR(_enum_name, _constructor_name) \
Dynamic(HX_CSTRING("Invalid enum constructor for ") + \
HX_CSTRING(_enum_name) + \
HX_CSTRING(": ") + \
_constructor_name)
#define HX_INVALID_OBJECT Dynamic(HX_CSTRING("Invalid object"))
#define HX_INVALID_ARG_COUNT Dynamic(HX_CSTRING("Invalid Arg Count"))
#define HX_NULL_FUNCTION_POINTER Dynamic(HX_CSTRING("Null Function Pointer"))
#define HX_INVALID_ENUM_ARG_COUNT(_enum_name, _constructor_name, _count, _expected) \
Dynamic(HX_CSTRING("Invalid enum arg count for ") + \
HX_CSTRING(_enum_name) + \
HX_CSTRING(".") + \
_constructor_name + \
HX_CSTRING(": expected ") + \
::String(_expected) + \
HX_CSTRING(", got ") + \
::String(_count))
#endif

304
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/FieldRef.h Normal file
View File

@ -0,0 +1,304 @@
#ifndef HX_FIELD_REF_H
#define HX_FIELD_REF_H
namespace hx
{
// --- FieldRef ----------------------------------------------------------
//
// This is used to provide syntaxe for setting fields by name. This is because
// the field can't be returned by reference, because it may not exist as a dynamic.
//
// eg, consider class 'A' with variable 'x':
// class A { int x; }
//
// And you have a Dynamic pointing to it:
// Dynamic d = new A; Then you access x by name:
// d->__Field("x") = 1;
//
// __Field can't return a Dynamic & because x is a int, not Dynamic. So I use this class.
// Note that this may change if I fix the generator to create __SetField("x",1) directly.
#define HX_FIELD_REF_MEM_OP(op,ret) \
inline ret operator op (const FieldRef &inA) \
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
inline ret operator op (const IndexRef &inA); \
template<typename T> inline ret operator op (const T& inA) \
{ return this->operator Dynamic() op inA; }
#define HX_FIELD_REF_IMPL_MEM_OP(op,ret) \
inline ret hx::FieldRef::operator op (const IndexRef &inA) \
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
class FieldRef
{
public:
explicit FieldRef(hx::Object *inObj,const String &inName) : mObject(inObj), mName(inName)
{
}
hx::Val operator=(const hx::Val &inRHS)
{
return mObject->__SetField(mName,inRHS, HX_PROP_DYNAMIC );
}
#if HXCPP_API_LEVEL >= 330
inline operator hx::Val() const { return mObject ? mObject->__Field(mName, HX_PROP_DYNAMIC) : null(); }
#endif
inline operator Dynamic() const { return mObject ? Dynamic(mObject->__Field(mName, HX_PROP_DYNAMIC)) : null(); }
inline operator double() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
inline operator float() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
inline operator int() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
inline operator cpp::UInt64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
inline operator cpp::Int64() const { return mObject->__Field(mName, HX_PROP_DYNAMIC); }
// post-increment
inline double operator++(int)
{
double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
mObject->__SetField(mName,d+1, HX_PROP_DYNAMIC);
return d;
}
// pre-increment
inline double operator++()
{
double d = ((double)mObject->__Field(mName, HX_PROP_DYNAMIC)) + 1;
mObject->__SetField(mName,d, HX_PROP_DYNAMIC);
return d;
}
// post-decrement
inline double operator--(int)
{
double d = mObject->__Field(mName, HX_PROP_DYNAMIC);
mObject->__SetField(mName,d-1, HX_PROP_DYNAMIC);
return d;
}
// pre-decrement
inline double operator--()
{
double d = (double)(mObject->__Field(mName, HX_PROP_DYNAMIC)) - 1;
mObject->__SetField(mName,d, HX_PROP_DYNAMIC);
return d;
}
bool operator !() { return ! ((int)(mObject->__Field(mName, HX_PROP_DYNAMIC))); }
int operator ~() { return ~ ((int)mObject->__Field(mName, HX_PROP_DYNAMIC)); }
inline bool operator==(const null &) const { return !mObject; }
inline bool operator!=(const null &) const { return mObject; }
double operator -() { return - (double)(mObject->__Field(mName, HX_PROP_DYNAMIC)); }
bool HasPointer() const { return mObject; }
HX_FIELD_REF_MEM_OP(==,bool)
HX_FIELD_REF_MEM_OP(!=,bool)
HX_FIELD_REF_MEM_OP(<,bool)
HX_FIELD_REF_MEM_OP(<=,bool)
HX_FIELD_REF_MEM_OP(>,bool)
HX_FIELD_REF_MEM_OP(>=,bool)
HX_FIELD_REF_MEM_OP(+,Dynamic)
HX_FIELD_REF_MEM_OP(*,double)
HX_FIELD_REF_MEM_OP(/,double)
HX_FIELD_REF_MEM_OP(-,double)
HX_FIELD_REF_MEM_OP(%,double)
String mName;
hx::Object *mObject;
};
// We can define this one now...
template<typename T>
inline FieldRef ObjectPtr<T>::FieldRef(const String &inString)
{
return hx::FieldRef(mPtr,inString);
}
#define HX_FIELD_REF_OP(op,ret) \
template<typename T> inline ret operator op (T &inT, const FieldRef &inA) \
{ return inT op ( inA.operator Dynamic()); }
HX_FIELD_REF_OP(==,bool)
HX_FIELD_REF_OP(!=,bool)
HX_FIELD_REF_OP(<,bool)
HX_FIELD_REF_OP(<=,bool)
HX_FIELD_REF_OP(>,bool)
HX_FIELD_REF_OP(>=,bool)
HX_FIELD_REF_OP(+,Dynamic)
HX_FIELD_REF_OP(*,double)
HX_FIELD_REF_OP(/,double)
HX_FIELD_REF_OP(-,double)
HX_FIELD_REF_OP(%,double)
// --- IndexRef --------------------------------------------------------------
//
// Like FieldRef, but for integer array access
//
#define HX_INDEX_REF_MEM_OP(op,ret) \
inline ret operator op (const IndexRef &inA) \
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
inline ret operator op (const FieldRef &inA) \
{ return this->operator Dynamic() op inA.operator Dynamic(); } \
template<typename T> inline ret operator op (const T& inA) \
{ return this->operator Dynamic() op inA; }
class IndexRef
{
public:
explicit IndexRef(hx::Object *inObj,int inIndex) : mObject(inObj), mIndex(inIndex)
{
}
Dynamic operator=(const Dynamic &inRHS)
{
return mObject->__SetItem(mIndex,inRHS);
}
inline operator Dynamic() const { return mObject->__GetItem(mIndex); }
inline operator double() const { return mObject->__GetItem(mIndex); }
inline operator int() const { return mObject->__GetItem(mIndex); }
// post-increment
inline double operator++(int)
{
double d = mObject->__GetItem(mIndex)->__ToDouble();
mObject->__SetItem(mIndex,d+1);
return d;
}
// pre-increment
inline double operator++()
{
double d = mObject->__GetItem(mIndex)->__ToDouble() + 1;
mObject->__SetItem(mIndex,d);
return d;
}
// post-decrement
inline double operator--(int)
{
double d = mObject->__GetItem(mIndex)->__ToDouble();
mObject->__SetItem(mIndex,d-1);
return d;
}
// pre-decrement
inline double operator--()
{
double d = mObject->__GetItem(mIndex)->__ToDouble() - 1;
mObject->__SetItem(mIndex,d);
return d;
}
bool operator !() { return ! mObject->__GetItem(mIndex)->__ToInt(); }
int operator ~() { return ~ mObject->__GetItem(mIndex)->__ToInt(); }
double operator -() { return - mObject->__GetItem(mIndex)->__ToDouble(); }
inline bool operator==(const null &) const { return !mObject; }
inline bool operator!=(const null &) const { return mObject; }
HX_INDEX_REF_MEM_OP(==,bool)
HX_INDEX_REF_MEM_OP(!=,bool)
HX_INDEX_REF_MEM_OP(<,bool)
HX_INDEX_REF_MEM_OP(<=,bool)
HX_INDEX_REF_MEM_OP(>,bool)
HX_INDEX_REF_MEM_OP(>=,bool)
HX_INDEX_REF_MEM_OP(+,Dynamic)
HX_INDEX_REF_MEM_OP(*,double)
HX_INDEX_REF_MEM_OP(/,double)
HX_INDEX_REF_MEM_OP(-,double)
HX_INDEX_REF_MEM_OP(%,double)
bool HasPointer() const { return mObject; }
int mIndex;
hx::Object *mObject;
};
// We can define this one now...
template<typename T>
inline IndexRef ObjectPtr<T>::IndexRef(int inIndex)
{
return hx::IndexRef(mPtr,inIndex);
}
#define HX_INDEX_REF_OP(op,ret) \
template<typename T> inline ret operator op (T &inT, const IndexRef &inA) \
{ return inT op ( inA. operator Dynamic()); }
HX_INDEX_REF_OP(==,bool)
HX_INDEX_REF_OP(!=,bool)
HX_INDEX_REF_OP(<,bool)
HX_INDEX_REF_OP(<=,bool)
HX_INDEX_REF_OP(>,bool)
HX_INDEX_REF_OP(>=,bool)
HX_INDEX_REF_OP(+,Dynamic)
HX_INDEX_REF_OP(*,double)
HX_INDEX_REF_OP(/,double)
HX_INDEX_REF_OP(-,double)
HX_INDEX_REF_OP(%,double)
// Implement once IndexRef has been defined.
HX_FIELD_REF_IMPL_MEM_OP(==,bool)
HX_FIELD_REF_IMPL_MEM_OP(!=,bool)
HX_FIELD_REF_IMPL_MEM_OP(<,bool)
HX_FIELD_REF_IMPL_MEM_OP(<=,bool)
HX_FIELD_REF_IMPL_MEM_OP(>,bool)
HX_FIELD_REF_IMPL_MEM_OP(>=,bool)
HX_FIELD_REF_IMPL_MEM_OP(+,Dynamic)
HX_FIELD_REF_IMPL_MEM_OP(*,double)
HX_FIELD_REF_IMPL_MEM_OP(/,double)
HX_FIELD_REF_IMPL_MEM_OP(-,double)
HX_FIELD_REF_IMPL_MEM_OP(%,double)
// Disambiguate Dynamic operators...
#define HX_INDEX_REF_OP_DYNAMIC(op,ret) \
inline ret operator op (const Dynamic &inT, const IndexRef &inA) \
{ return inT op ( inA.operator Dynamic()); }
HX_INDEX_REF_OP_DYNAMIC(==,bool)
HX_INDEX_REF_OP_DYNAMIC(!=,bool)
HX_INDEX_REF_OP_DYNAMIC(+,Dynamic)
HX_INDEX_REF_OP_DYNAMIC(*,double)
template<typename _OBJ>
class __TArrayImplRef
{
public:
_OBJ mObject;
int mIndex;
explicit __TArrayImplRef(_OBJ inObj,int inIndex) : mObject(inObj), mIndex(inIndex) { }
template<typename _DATA>
inline operator _DATA() { return mObject->__get(mIndex); }
template<typename _DATA>
inline void operator=(_DATA inRHS)
{
mObject->__set(mIndex,inRHS);
}
};
template<typename _OBJ>
__TArrayImplRef<_OBJ> __ArrayImplRef(_OBJ inObj, int inIndex)
{
return __TArrayImplRef<_OBJ>(inObj,inIndex);
}
} // end namespace hx
#endif

28
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Functions.h Normal file
View File

@ -0,0 +1,28 @@
#ifndef HX_FUNCTIONS_H
#define HX_FUNCTIONS_H
#include <hxcpp.h>
namespace hx
{
struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalFunc : public hx::Object
{
int __GetType() const { return vtFunction; }
inline void DoMarkThis(hx::MarkContext *__inCtx) { }
#ifdef HXCPP_VISIT_ALLOCS
inline void DoVisitThis(hx::VisitContext *__inCtx) { }
#endif
};
struct HXCPP_EXTERN_CLASS_ATTRIBUTES LocalThisFunc : public LocalFunc
{
Dynamic __this;
void __SetThis(Dynamic inThis) { __this = inThis; }
inline void DoMarkThis(hx::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); }
#ifdef HXCPP_VISIT_ALLOCS
inline void DoVisitThis(hx::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
#endif
};
}
#endif

580
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GC.h Normal file
View File

@ -0,0 +1,580 @@
#ifndef HX_GC_H
#define HX_GC_H
#include <hx/Tls.h>
#include <stdio.h>
// Under the current scheme (as defined by HX_HCSTRING/HX_CSTRING in hxcpp.h)
// each constant string data is prepended with a 4-byte header that says the string
// is constant (ie, not part of GC) and whether there is(not) a pre-computed hash at
// the end of the data.
// When HX_SMART_STRINGS is active, a bit says whether it is char16_t encoded.
#define HX_GC_CONST_ALLOC_BIT 0x80000000
#define HX_GC_CONST_ALLOC_MARK_BIT 0x80
// Tell compiler the extra functions are supported
#define HXCPP_GC_FUNCTIONS_1
// Function called by the haxe code...
#ifdef HXCPP_TELEMETRY
extern void __hxt_gc_new(hx::StackContext *inStack, void* obj, int inSize, const char *inName);
#endif
// Helpers for debugging code
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_reachable(hx::Object *inKeep);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_enable(bool inEnable);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_collect(bool inMajor=true);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_gc_compact();
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_gc_trace(hx::Class inClass, bool inPrint);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_gc_used_bytes();
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_gc_mem_info(int inWhat);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_enter_gc_free_zone();
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_exit_gc_free_zone();
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_gc_safe_point();
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_spam_collects(int inEveryNCalls);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_minimum_working_memory(int inBytes);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_minimum_free_space(int inBytes);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_target_free_space_percentage(int inPercentage);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_is_const_string(const ::String &inString);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_gc_freeze(Dynamic inObject);
typedef void (hx::Object::*_hx_member_finalizer)(void);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_member_finalizer(hx::Object *inObject, _hx_member_finalizer, bool inPin);
typedef void (*_hx_alloc_finalizer)(void *inPtr);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_add_alloc_finalizer(void *inAlloc, _hx_alloc_finalizer, bool inPin);
template<typename T>
inline void _hx_add_finalizable( hx::ObjectPtr<T> inObj, bool inPin)
{
_hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
__hxcpp_add_member_finalizer(inObj.mPtr, finalizer, inPin);
}
template<typename T>
inline void _hx_add_finalizable( T *inObj, bool inPin)
{
_hx_member_finalizer finalizer = (_hx_member_finalizer)&T::finalize;
__hxcpp_add_member_finalizer(inObj, finalizer, inPin);
}
template<typename T>
T _hx_allocate_extended(int inExtra)
{
typedef typename T::Obj Obj;
Obj *obj = new (inExtra) Obj();
return obj;
}
/*
template<typename T>
inline void _hx_allocate_extended( hx::ObjectPtr<T> inObj, bool inPin)
*/
// Finalizers from haxe code...
void __hxcpp_gc_do_not_kill(Dynamic inObj);
// This is the correctly typed version - no change of getting function proto wrong
void _hx_set_finalizer(Dynamic inObj, void (*inFunc)(Dynamic) );
void __hxcpp_set_finalizer(Dynamic inObj, void *inFunction);
hx::Object *__hxcpp_get_next_zombie();
#ifdef HXCPP_TELEMETRY
void __hxcpp_set_hxt_finalizer(void* inObj, void *inFunc);
#endif
hx::Object *__hxcpp_weak_ref_create(Dynamic inObject);
hx::Object *__hxcpp_weak_ref_get(Dynamic inRef);
unsigned int __hxcpp_obj_hash(Dynamic inObj);
int __hxcpp_obj_id(Dynamic inObj);
hx::Object *__hxcpp_id_obj(int);
namespace hx
{
// Generic allocation routine.
// If inSize is small (<4k) it will be allocated from the immix pool.
// Larger, and it will be allocated from a separate memory pool
// inIsObject specifies whether "__Mark" should be called on the resulting object
void *InternalNew(int inSize,bool inIsObject);
// Used internall - realloc array data
void *InternalRealloc(int inFromSize, void *inData,int inSize,bool inAllowExpansion=false);
void InternalReleaseMem(void *inMem);
unsigned int ObjectSizeSafe(void *inData);
// Const buffers are allocated outside the GC system, and do not require marking
// String buffers can optionally have a pre-computed hash appended with this method
void *InternalCreateConstBuffer(const void *inData,int inSize,bool inAddStringHash=false);
// Called after collection by an unspecified thread
typedef void (*finalizer)(hx::Object *v);
// Used internally by the runtime.
// The constructor will add this object to the internal list of finalizers.
// If the parent object is not marked by the end of the collect, the finalizer will trigger.
struct InternalFinalizer
{
InternalFinalizer(hx::Object *inObj, finalizer inFinalizer=0);
#ifdef HXCPP_VISIT_ALLOCS
void Visit(VisitContext *__inCtx);
#endif
void Detach();
bool mValid;
finalizer mFinalizer;
hx::Object *mObject;
};
// Attach a finalizer to any object allocation. This can be called from haxe code, but be aware that
// you can't make any GC calls from the finalizer.
void GCSetFinalizer( hx::Object *, hx::finalizer f );
// If another thread wants to do a collect, it will signal this variable.
// This automatically gets checked when you call "new", but if you are in long-running
// loop with no new call, you might starve another thread if you to not check this.
// 0xffffffff = pause requested
extern int gPauseForCollect;
// Minimum total memory - used + buffer for new objects
extern int sgMinimumWorkingMemory;
// Minimum free memory - not counting used memory
extern int sgMinimumFreeSpace;
// Also ensure that the free memory is larger than this amount of used memory
extern int sgTargetFreeSpacePercentage;
extern HXCPP_EXTERN_CLASS_ATTRIBUTES int gByteMarkID;
// Call in response to a gPauseForCollect. Normally, this is done for you in "new"
void PauseForCollect();
// Used by WeakHash to work out if it needs to dispose its keys
bool IsWeakRefValid(hx::Object *inPtr);
bool IsWeakRefValid(const HX_CHAR *inPtr);
// Used by CFFI to scan a block of memory for GC Pointers. May picks up random crap
// that points to real, active objects.
void MarkConservative(int *inBottom, int *inTop,hx::MarkContext *__inCtx);
// Create/Remove a root.
// All statics are explicitly registered - this saves adding the whole data segment
// to the collection list.
// It takes a pointer-pointer so it can move the contents, and the caller can change the contents
void GCAddRoot(hx::Object **inRoot);
void GCRemoveRoot(hx::Object **inRoot);
// This is used internally in hxcpp
// It calls InternalNew, and takes care of null-terminating the result
char *NewString(int inLen);
// The concept of 'private' is from the old conservative Gc method.
// Now with explicit marking, these functions do the same thing, which is
// to allocate some GC memory and optionally copy the 'inData' into those bytes
HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCBytes(void *inData,int inSize);
HXCPP_EXTERN_CLASS_ATTRIBUTES void *NewGCPrivate(void *inData,int inSize);
// Force a collect from the calling thread
// Only one thread should call this at a time
int InternalCollect(bool inMajor,bool inCompact);
// Disable the garbage collector. It will try to increase its internal buffers to honour extra requests.
// If it runs out of memory, it will actually try to do a collect.
void InternalEnableGC(bool inEnable);
// Record that fact that external memory has been allocated and associated with a haxe object
// eg. BitmapData. This will help the collector know when to collect
void GCChangeManagedMemory(int inDelta, const char *inWhy=0);
// Haxe threads can center GC free zones, where they can't make GC allocation calls, and should not mess with GC memory.
// This means that they do not need to pause while the GC collections happen, and other threads will not
// wait for them to "check in" before collecting. The standard runtime makes these calls around OS calls, such as "Sleep"
void EnterGCFreeZone();
void ExitGCFreeZone();
// retuns true if ExitGCFreeZone should be called
bool TryGCFreeZone();
// retuns true if ExitGCFreeZone was called
bool TryExitGCFreeZone();
class HXCPP_EXTERN_CLASS_ATTRIBUTES AutoGCFreeZone
{
public:
AutoGCFreeZone() : locked(true) { EnterGCFreeZone(); }
~AutoGCFreeZone() { if (locked) ExitGCFreeZone(); }
void close() { if (locked) ExitGCFreeZone(); locked = false; }
bool locked;
};
// Defined in Class.cpp, these function is called from the Gc to start the marking/visiting
void MarkClassStatics(hx::MarkContext *__inCtx);
#ifdef HXCPP_VISIT_ALLOCS
void VisitClassStatics(hx::VisitContext *__inCtx);
#endif
// Called by haxe/application code to mark allocations.
// "Object" allocs will recursively call __Mark
inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx);
inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx);
// Implemented differently for efficiency
void MarkObjectArray(hx::Object **inPtr, int inLength, hx::MarkContext *__inCtx);
void MarkStringArray(String *inPtr, int inLength, hx::MarkContext *__inCtx);
// Provide extra debug info to the marking routines
#ifdef HXCPP_DEBUG
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkSetMember(const char *inName ,hx::MarkContext *__inCtx);
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPushClass(const char *inName ,hx::MarkContext *__inCtx);
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkPopClass(hx::MarkContext *__inCtx);
#endif
// Used by runtime if it is being paranoid about pointers. It checks that the pointer is real and alive at last collect.
void GCCheckPointer(void *);
void GCOnNewPointer(void *);
// Called internally before and GC operations
void CommonInitAlloc();
// Threading ...
void RegisterNewThread(void *inTopOfStack);
void RegisterCurrentThread(void *inTopOfStack);
void UnregisterCurrentThread();
void GCPrepareMultiThreaded();
} // end namespace hx
// Inline code tied to the immix implementation
namespace hx
{
#define HX_USE_INLINE_IMMIX_OPERATOR_NEW
//#define HX_STACK_CTX ::hx::ImmixAllocator *_hx_stack_ctx = hx::gMultiThreadMode ? hx::tlsImmixAllocator : hx::gMainThreadAlloc;
// Each line ast 128 bytes (2^7)
#define IMMIX_LINE_BITS 7
#define IMMIX_LINE_LEN (1<<IMMIX_LINE_BITS)
#define HX_GC_REMEMBERED 0x40
// The size info is stored in the header 8 bits to the right
#define IMMIX_ALLOC_SIZE_SHIFT 6
// Indicates that __Mark must be called recursively
#define IMMIX_ALLOC_IS_CONTAINER 0x00800000
// String is char16_t type
#define HX_GC_STRING_CHAR16_T 0x00200000
// String has hash data at end
#define HX_GC_STRING_HASH 0x00100000
#define HX_GC_STRING_HASH_BIT 0x10
#ifdef HXCPP_BIG_ENDIAN
#define HX_GC_STRING_HASH_OFFSET -3
#define HX_GC_CONST_ALLOC_MARK_OFFSET -4
#define HX_ENDIAN_MARK_ID_BYTE -4
#else
#define HX_GC_STRING_HASH_OFFSET -2
#define HX_GC_CONST_ALLOC_MARK_OFFSET -1
#define HX_ENDIAN_MARK_ID_BYTE -1
#endif
// The gPauseForCollect bits will turn spaceEnd negative, and so force the slow path
#ifndef HXCPP_SINGLE_THREADED_APP
#define WITH_PAUSE_FOR_COLLECT_FLAG | hx::gPauseForCollect
#else
#define WITH_PAUSE_FOR_COLLECT_FLAG
#endif
struct StackContext;
EXTERN_FAST_TLS_DATA(StackContext, tlsStackContext);
extern StackContext *gMainThreadContext;
extern unsigned int gImmixStartFlag[128];
extern int gMarkID;
extern int gMarkIDWithContainer;
extern void BadImmixAlloc();
class ImmixAllocator
{
public:
virtual ~ImmixAllocator() {}
virtual void *CallAlloc(int inSize,unsigned int inObjectFlags) = 0;
virtual void SetupStackAndCollect(bool inMajor, bool inForceCompact, bool inLocked=false,bool inFreeIsFragged=false) = 0;
#ifdef HXCPP_GC_NURSERY
unsigned char *spaceFirst;
unsigned char *spaceOversize;
#else
int spaceStart;
int spaceEnd;
#endif
unsigned int *allocStartFlags;
unsigned char *allocBase;
// These allocate the function using the garbage-colleced malloc
inline static void *alloc(ImmixAllocator *alloc, size_t inSize, bool inContainer, const char *inName )
{
#ifdef HXCPP_GC_NURSERY
unsigned char *buffer = alloc->spaceFirst;
unsigned char *end = buffer + (inSize + 4);
if ( end > alloc->spaceOversize )
{
// Fall back to external method
buffer = (unsigned char *)alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
}
else
{
alloc->spaceFirst = end;
if (inContainer)
((unsigned int *)buffer)[-1] = inSize | IMMIX_ALLOC_IS_CONTAINER;
else
((unsigned int *)buffer)[-1] = inSize;
}
#ifdef HXCPP_TELEMETRY
__hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
#endif
return buffer;
#else
#ifndef HXCPP_ALIGN_ALLOC
// Inline the fast-path if we can
// We know the object can hold a pointer (vtable) and that the size is int-aligned
int start = alloc->spaceStart;
int end = start + sizeof(int) + inSize;
if ( end <= alloc->spaceEnd )
{
alloc->spaceStart = end;
unsigned int *buffer = (unsigned int *)(alloc->allocBase + start);
int startRow = start>>IMMIX_LINE_BITS;
alloc->allocStartFlags[ startRow ] |= gImmixStartFlag[start&127];
if (inContainer)
*buffer++ = (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
(inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
hx::gMarkIDWithContainer;
else
*buffer++ = (( (end+(IMMIX_LINE_LEN-1))>>IMMIX_LINE_BITS) -startRow) |
(inSize<<IMMIX_ALLOC_SIZE_SHIFT) |
hx::gMarkID;
#if defined(HXCPP_GC_CHECK_POINTER) && defined(HXCPP_GC_DEBUG_ALWAYS_MOVE)
hx::GCOnNewPointer(buffer);
#endif
#ifdef HXCPP_TELEMETRY
__hxt_gc_new((hx::StackContext *)alloc,buffer, inSize, inName);
#endif
return buffer;
}
#endif // HXCPP_ALIGN_ALLOC
// Fall back to external method
void *result = alloc->CallAlloc(inSize, inContainer ? IMMIX_ALLOC_IS_CONTAINER : 0);
#ifdef HXCPP_TELEMETRY
__hxt_gc_new((hx::StackContext *)alloc,result, inSize, inName);
#endif
return result;
#endif // HXCPP_GC_NURSERY
}
};
typedef ImmixAllocator GcAllocator;
typedef ImmixAllocator Ctx;
#ifdef HXCPP_GC_GENERATIONAL
#define HX_OBJ_WB_CTX(obj,value,ctx) { \
unsigned char &mark = ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
if (mark == hx::gByteMarkID && value && !((unsigned char *)(value))[ HX_ENDIAN_MARK_ID_BYTE ] ) { \
mark|=HX_GC_REMEMBERED; \
ctx->pushReferrer(obj); \
} }
#define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx) { \
unsigned char &mark = ((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]; \
if (mark == hx::gByteMarkID) { \
mark|=HX_GC_REMEMBERED; \
ctx->pushReferrer(obj); \
} }
// I'm not sure if this will ever trigger...
#define HX_OBJ_WB_NEW_MARKED_OBJECT(obj) { \
if (((unsigned char *)(obj))[ HX_ENDIAN_MARK_ID_BYTE]==hx::gByteMarkID) hx::NewMarkedObject(obj); \
}
#else
#define HX_OBJ_WB_CTX(obj,value,ctx)
#define HX_OBJ_WB_PESSIMISTIC_CTX(obj,ctx)
#define HX_OBJ_WB_NEW_MARKED_OBJECT(obj)
#endif
#define HX_OBJ_WB(obj,value) HX_OBJ_WB_CTX(obj,value,_hx_ctx)
#define HX_ARRAY_WB(array,index,value) HX_OBJ_WB(array,value)
#define HX_OBJ_WB_PESSIMISTIC(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,_hx_ctx)
#define HX_OBJ_WB_GET(obj,value) HX_OBJ_WB_CTX(obj,value,HX_CTX_GET)
#define HX_OBJ_WB_PESSIMISTIC_GET(obj) HX_OBJ_WB_PESSIMISTIC_CTX(obj,HX_CTX_GET)
HXCPP_EXTERN_CLASS_ATTRIBUTES extern unsigned int gPrevMarkIdMask;
// Called only once it is determined that a new mark is required
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkAllocUnchecked(void *inPtr ,hx::MarkContext *__inCtx);
HXCPP_EXTERN_CLASS_ATTRIBUTES void MarkObjectAllocUnchecked(hx::Object *inPtr ,hx::MarkContext *__inCtx);
HXCPP_EXTERN_CLASS_ATTRIBUTES void NewMarkedObject(hx::Object *inPtr);
inline void MarkAlloc(void *inPtr ,hx::MarkContext *__inCtx)
{
#ifdef EMSCRIPTEN
// Unaligned must be constants...
if ( !( ((size_t)inPtr) & 3) )
#endif
// This will also skip const regions
if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
MarkAllocUnchecked(inPtr,__inCtx);
}
inline void MarkObjectAlloc(hx::Object *inPtr ,hx::MarkContext *__inCtx)
{
#ifdef EMSCRIPTEN
// Unaligned must be constants...
if ( !( ((size_t)inPtr) & 3) )
#endif
// This will also skip const regions
if ( !(((unsigned int *)inPtr)[-1] & gPrevMarkIdMask) )
MarkObjectAllocUnchecked(inPtr,__inCtx);
}
} // end namespace hx
// It was theoretically possible to redefine the MarkContext arg type (or skip it)
// incase the particular GC scheme did not need it. This may take a bit of extra
// work to get going again
#define HX_MARK_ARG __inCtx
//#define HX_MARK_ADD_ARG ,__inCtx
#define HX_MARK_PARAMS hx::MarkContext *__inCtx
//#define HX_MARK_ADD_PARAMS ,hx::MarkContext *__inCtx
#ifdef HXCPP_VISIT_ALLOCS
#define HX_VISIT_ARG __inCtx
#define HX_VISIT_PARAMS hx::VisitContext *__inCtx
#else
#define HX_VISIT_ARG
#define HX_VISIT_PARAMS
#endif
// These macros add debug to the mark/visit calls if required
// They also perform some inline checking to avoid function calls if possible
#ifdef HXCPP_DEBUG
#define HX_MARK_MEMBER_NAME(x,name) { hx::MarkSetMember(name, __inCtx); hx::MarkMember(x, __inCtx ); }
#define HX_MARK_BEGIN_CLASS(x) hx::MarkPushClass(#x, __inCtx );
#define HX_MARK_END_CLASS() hx::MarkPopClass(__inCtx );
#define HX_MARK_MEMBER(x) { hx::MarkSetMember(0, __inCtx); hx::MarkMember(x, __inCtx ); }
#define HX_MARK_MEMBER_ARRAY(x,len) { hx::MarkSetMember(0, __inCtx); hx::MarkMemberArray(x, len, __inCtx ); }
#else
#define HX_MARK_MEMBER_NAME(x,name) hx::MarkMember(x, __inCtx )
#define HX_MARK_BEGIN_CLASS(x)
#define HX_MARK_END_CLASS()
#define HX_MARK_MEMBER(x) hx::MarkMember(x, __inCtx )
#define HX_MARK_MEMBER_ARRAY(x,len) hx::MarkMemberArray(x, len, __inCtx )
#endif
#define HX_MARK_OBJECT(ioPtr) if (ioPtr) hx::MarkObjectAlloc(ioPtr, __inCtx );
#define HX_MARK_STRING(ioPtr) \
if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx );
#define HX_MARK_ARRAY(ioPtr) { if (ioPtr) hx::MarkAlloc((void *)ioPtr, __inCtx ); }
#define HX_VISIT_MEMBER_NAME(x,name) hx::VisitMember(x, __inCtx )
#define HX_VISIT_MEMBER(x) hx::VisitMember(x, __inCtx )
#define HX_VISIT_OBJECT(ioPtr) \
{ if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitObject( (hx::Object **)&ioPtr); }
#define HX_VISIT_STRING(ioPtr) \
if (ioPtr && !(((unsigned char *)ioPtr)[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT) ) __inCtx->visitAlloc((void **)&ioPtr);
#define HX_VISIT_ARRAY(ioPtr) { if (ioPtr) __inCtx->visitAlloc((void **)&ioPtr); }
#endif

161
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GcTypeInference.h Normal file
View File

@ -0,0 +1,161 @@
#ifndef HX_GC_TYPE_INFERENCE_H
#define HX_GC_TYPE_INFERENCE_H
// These templates allow you to call MarkMember(x) or VisitMember(x) and the
// compiler will direct the call to the correct function
namespace hx
{
template<typename T> inline void MarkMember(T &outT,hx::MarkContext *__inCtx) { }
template<typename T> inline void MarkMember(hx::ObjectPtr<T> &outT,hx::MarkContext *__inCtx)
{
HX_MARK_OBJECT(outT.mPtr);
}
template<> inline void MarkMember(Dynamic &outT,hx::MarkContext *__inCtx)
{
HX_MARK_OBJECT(outT.mPtr);
}
template<typename T> inline void MarkMember(Array<T> &outT,hx::MarkContext *__inCtx)
{
HX_MARK_OBJECT(outT.mPtr);
}
template<> inline void MarkMember<hx::Object *>(hx::Object *&outT,hx::MarkContext *__inCtx)
{
HX_MARK_OBJECT(outT);
}
template<> inline void MarkMember<cpp::Variant>(cpp::Variant &outT,hx::MarkContext *__inCtx)
{
outT.mark(__inCtx);
}
template<typename T> inline void MarkMember(hx::Native<T> &outT,hx::MarkContext *__inCtx)
{
if (outT.ptr)
{
hx::Object *ptr = outT.ptr->__GetRealObject();
HX_MARK_OBJECT(ptr);
}
}
template<> inline void MarkMember<int>(int &outT,hx::MarkContext *__inCtx) { }
template<> inline void MarkMember<bool>(bool &outT,hx::MarkContext *__inCtx) { }
template<> inline void MarkMember<double>(double &outT,hx::MarkContext *__inCtx) { }
template<> inline void MarkMember<float>(float &outT,hx::MarkContext *__inCtx) { }
template<> inline void MarkMember<String>(String &outT,hx::MarkContext *__inCtx)
{
HX_MARK_STRING(outT.raw_ptr());
}
template<> inline void MarkMember<null>(null &outT,hx::MarkContext *__inCtx) { }
template<typename T> inline void MarkMemberArray(T *,int, hx::MarkContext *__inCtx)
{
//*(int *)0=0;
}
template<> inline void MarkMemberArray<String>(String *ioStrings,int inLen,hx::MarkContext *__inCtx)
{
hx::MarkStringArray(ioStrings,inLen,__inCtx);
}
template<typename T> inline void MarkMemberArray(hx::ObjectPtr<T> *inObjects, int inLen, hx::MarkContext *__inCtx)
{
hx::MarkObjectArray( (hx::Object **)inObjects ,inLen,__inCtx);
}
template<> inline void MarkMemberArray(Dynamic *outT,int inLen, hx::MarkContext *__inCtx)
{
hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
}
template<> inline void MarkMemberArray(hx::Object **outT,int inLen, hx::MarkContext *__inCtx)
{
hx::MarkObjectArray( outT ,inLen,__inCtx);
}
template<typename T> inline void MarkMemberArray(Array<T> *outT,int inLen,hx::MarkContext *__inCtx)
{
hx::MarkObjectArray( (hx::Object **)outT ,inLen,__inCtx);
}
// Locate potential GC pointer inside member
inline const void *PointerOf( ::Dynamic &d) { return d.mPtr; }
inline const void *PointerOf( ::String &s) { return s.raw_ptr(); }
template<typename T> inline const void *PointerOf( ::Array<T> &a) { return a.mPtr; }
template<typename T> inline const void *PointerOf( ::hx::ObjectPtr<T> &o) { return o.mPtr; }
template<typename T> inline const void *PointerOf( ::hx::Native<T> &o)
{
if (o.ptr)
return o.ptr->__GetRealObject();
return 0;
}
inline const void *PointerOf(...) { return 0; }
#ifdef HXCPP_VISIT_ALLOCS
template<typename T> inline void VisitMember(T &outT,hx::VisitContext *__inCtx) { }
template<typename T> inline void VisitMember(hx::ObjectPtr<T> &outT,hx::VisitContext *__inCtx)
{
HX_VISIT_OBJECT(outT.mPtr);
}
template<> inline void VisitMember(Dynamic &outT,hx::VisitContext *__inCtx)
{
HX_VISIT_OBJECT(outT.mPtr);
}
template<> inline void VisitMember<hx::Object *>(hx::Object *&outT,hx::VisitContext *__inCtx)
{
HX_VISIT_OBJECT(outT);
}
template<typename T> inline void VisitMember(Array<T> &outT,hx::VisitContext *__inCtx)
{
HX_VISIT_OBJECT(outT.mPtr);
}
template<> inline void VisitMember(cpp::Variant &outT,hx::VisitContext *__inCtx)
{
outT.visit(__inCtx);
}
template<typename T> inline void VisitMember(hx::Native<T> &outT,hx::VisitContext *__inCtx)
{
if (outT.ptr)
{
hx::Object *ptr0 = outT.ptr->__GetRealObject();
if (ptr0)
{
hx::Object *ptr1 = ptr0;
HX_VISIT_OBJECT(ptr1);
size_t delta = ( (char *)ptr1 - (char *)ptr0 );
if (delta)
outT.ptr = (T)( (char *)outT.ptr + delta );
}
}
}
template<> inline void VisitMember<int>(int &outT,hx::VisitContext *__inCtx) { }
template<> inline void VisitMember<bool>(bool &outT,hx::VisitContext *__inCtx) { }
template<> inline void VisitMember<double>(double &outT,hx::VisitContext *__inCtx) { }
template<> inline void VisitMember<float>(float &outT,hx::VisitContext *__inCtx) { }
template<> inline void VisitMember<String>(String &outT,hx::VisitContext *__inCtx)
{
HX_VISIT_STRING(outT.raw_ref());
}
template<> inline void VisitMember<null>(null &outT,hx::VisitContext *__inCtx) { }
#endif
// Template used to register and initialise the statics in the one call.
// Do nothing...
template<typename T> inline T &Static(T &t) { return t; }
} // end namespace hx
#endif

135
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/GenMacro.hx Normal file
View File

@ -0,0 +1,135 @@
/*
This file is used to generate Macros.h and DynamicImpl.h.
To change the number of "fast" args, you will also need to change numbers in the tpl files.
Usage: haxe -x GenMacro.hx
*/
import haxe.Template;
#if haxe3
import sys.io.File;
import sys.io.FileOutput;
#else
import neko.io.File;
import neko.io.FileOutput;
#end
class GenMacro
{
static var warning =
"// ## ## ## ## #### ## ## ## ## ## #### ##\n" +
"// ## ## ## ## ## ## ## ### ## ## ### ## ## ##\n" +
"// ## ## ## ###### ###### ###### ## ###### ## ### ##\n" +
"// ## ## ## ## ## ## ## ## ### ## ## ### ## ## \n" +
"// ## ## ## ## ## ## ## ## ## ## ## #### ##\n\n" +
"// DO NOT EDIT\n// This file is generated from the .tpl file\n";
public function new()
{
var context = { };
var params = new Array<Dynamic>();
var arr_list = new Array<String>();
var arg_list = new Array<String>();
var dynamic_arg_list = new Array<String>();
var dynamic_in_args = new Array<String>();
var dynamic_var_args = new Array<String>();
var dynamic_adds = new Array<String>();
for(arg in 0...27)
{
if (arg>0)
{
arr_list.push( "inArgs[" + (arg-1) + "]");
arg_list.push( "inArg" + (arg-1));
dynamic_arg_list.push("const Dynamic &inArg" + (arg-1) );
dynamic_adds.push( "->init(" + (arg-1) + ",inArg" + (arg-1) + ")" );
}
params.push( {
ARG : arg,
ARR_LIST : arr_list.join(","),
DYNAMIC_ARG_LIST : dynamic_arg_list.join(","),
ARG_LIST : arg_list.join(","),
DYNAMIC_ADDS : dynamic_adds.join("")
} );
}
var locals = new Array<Dynamic>();
var jumboLocals = new Array<Dynamic>();
var marks = new Array<String>();
var visits = new Array<String>();
var type_vars = new Array<String>();
var type_args = new Array<String>();
var construct_args = new Array<String>();
var construct_vars = new Array<String>();
for(arg in 1...62)
{
var vid = arg-1;
if (vid>=0)
{
marks.push( "HX_MARK_MEMBER(v" + vid +");" );
visits.push( "HX_VISIT_MEMBER(v" + vid +");" );
type_args.push( "t" + vid +",v" + vid );
type_vars.push( "t" + vid +" v" + vid );
construct_args.push( "t" + vid +" __" + vid );
construct_vars.push( "v" + vid +"(__" + vid + ")" );
}
var local = {
ARG : arg,
MARKS : marks.join(" "),
VISITS : visits.join(" "),
TYPE_VARS : type_vars.join(","),
TYPE_ARGS : type_args.join(","),
TYPE_DECL : type_vars.join(";"),
CONSTRUCT_VARS : construct_vars.join(","),
CONSTRUCT_ARGS : construct_args.join(",")
};
if (arg<20)
locals.push(local);
else
jumboLocals.push(local);
}
Reflect.setField(context, "PARAMS", params);
Reflect.setField(context, "LOCALS", locals);
Reflect.setField(context, "NS", "::");
Reflect.setField(context, "hxNS", " ::hx::");
var fixed = File.getContent("MacrosFixed.h");
fixed = fixed.split("
").join("");
var fileContents:String = File.getContent("Macros.tpl");
fileContents = fileContents.split("
").join("");
var template:Template = new Template(fileContents);
var result:String = template.execute(context);
var fileOutput:FileOutput = File.write("Macros.h", true);
fileOutput.writeString(warning);
fileOutput.writeString(fixed);
fileOutput.writeString(result);
fileOutput.close();
var fileContents:String = File.getContent("MacrosJumbo.tpl");
fileContents = fileContents.split("
").join("");
var template:Template = new Template(fileContents);
Reflect.setField(context, "LOCALS", jumboLocals);
var result:String = template.execute(context);
var fileOutput:FileOutput = File.write("MacrosJumbo.h", true);
fileOutput.writeString(warning);
fileOutput.writeString(result);
fileOutput.close();
var fileContents:String = File.getContent("DynamicImpl.tpl");
fileContents = fileContents.split("
").join("");
var template:Template = new Template(fileContents);
var result:String = template.execute(context);
var fileOutput:FileOutput = File.write("DynamicImpl.h", true);
fileOutput.writeString(warning);
fileOutput.writeString(result);
fileOutput.close();

3
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HeaderVersion.h Normal file
View File

@ -0,0 +1,3 @@
#ifndef HXCPP_HEADER_VERSION
#define HXCPP_HEADER_VERSION 330
#endif

114
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/HxcppMain.h Normal file
View File

@ -0,0 +1,114 @@
#ifdef HXCPP_DLL_IMPORT
extern "C" EXPORT_EXTRA void __main__()
{
__boot_all();
__hxcpp_main();
}
#elif defined(HX_ANDROID) && !defined(HXCPP_EXE_LINK)
// Java Main....
#include <jni.h>
#include <hx/Thread.h>
#include <android/log.h>
extern "C" EXPORT_EXTRA void hxcpp_main()
{
HX_TOP_OF_STACK
try
{
hx::Boot();
__boot_all();
__hxcpp_main();
}
catch (Dynamic e)
{
__hx_dump_stack();
__android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e==null() ? "null" : e->toString().__CStr());
}
hx::SetTopOfStack((int *)0,true);
}
extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env)
{
hxcpp_main();
}
#elif defined(HX_WINRT) && defined(__cplusplus_winrt)
#include <Roapi.h>
[ Platform::MTAThread ]
int main(Platform::Array<Platform::String^>^)
{
HX_TOP_OF_STACK
RoInitialize(RO_INIT_MULTITHREADED);
hx::Boot();
try
{
__boot_all();
__hxcpp_main();
}
catch (Dynamic e)
{
__hx_dump_stack();
return -1;
}
return 0;
}
#else
#if defined(HX_WIN_MAIN) && !defined(_WINDOWS_)
#ifndef HINSTANCE
#define HINSTANCE void*
#endif
#ifndef LPSTR
#define LPSTR char*
#endif
extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int);
#endif
#if defined(TIZEN)
extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[])
{
#elif defined(HX_WIN_MAIN)
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
#else
extern int _hxcpp_argc;
extern char **_hxcpp_argv;
int main(int argc,char **argv)
{
_hxcpp_argc = argc;
_hxcpp_argv = argv;
#endif
HX_TOP_OF_STACK
hx::Boot();
try
{
__boot_all();
__hxcpp_main();
}
catch (Dynamic e)
{
__hx_dump_stack();
#ifdef HX_WIN_MAIN
MessageBoxA(0, e==null() ? "null" : e->toString().__CStr(), "Error", 0);
#else
printf("Error : %s\n",e==null() ? "null" : e->toString().__CStr());
#endif
return -1;
}
return 0;
}
#if 0
}
}
#endif
#endif

9
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/IndexRef.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef HX_INDEX_REF_H
#define HX_INDEX_REF_H
namespace hx
{
}
#endif

65
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Interface.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef HX_INTERFACE_H
#define HX_INTERFACE_H
namespace hx
{
HXCPP_EXTERN_CLASS_ATTRIBUTES void InvalidInterface();
template<typename T>
inline T interface_cast(void *ptr)
{
#if defined(HXCPP_GC_CHECK_POINTER) || defined(HXCPP_DEBUG)
if (!ptr) hx::InvalidInterface();
#endif
return static_cast<T>(ptr);
}
#if (HXCPP_API_LEVEL >= 330)
template<typename T>
inline T interface_check(T inObj,int interfaceId)
{
Dynamic d(inObj);
if ( !d.mPtr || !d->_hx_getInterface(interfaceId))
hx::BadCast();
return inObj;
}
#endif
#if (HXCPP_API_LEVEL < 330)
class HXCPP_EXTERN_CLASS_ATTRIBUTES Interface : public hx::Object
{
public:
// The following functions make use of : hx::Object *__GetRealObject();
void __Mark(hx::MarkContext *__inCtx);
hx::Object *__ToInterface(const hx::type_info &);
int __GetType() const;
void *__GetHandle() const;
hx::FieldRef __FieldRef(const ::String &);
::String __ToString() const;
int __ToInt() const;
double __ToDouble() const;
const char * __CStr() const;
::String toString();
bool __HasField(const ::String &);
hx::Val __Field(const ::String &, hx::PropertyAccess inCallProp);
Dynamic __IField(int);
hx::Val __SetField(const ::String &,const hx::Val &, hx::PropertyAccess inCallProp);
void __SetThis(Dynamic);
void __GetFields(Array< ::String> &);
hx::Class __GetClass() const;
int __Compare(const hx::Object *) const;
/* No need for enum options - not in interfaces */
/* No need for array options - not in interfaces */
/* No need for function options - not in interfaces */
};
#endif
}
#endif

475
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/LessThanEq.h Normal file
View File

@ -0,0 +1,475 @@
#ifndef HX_LESS_THAN_EQ_INCLUDED
#define HX_LESS_THAN_EQ_INCLUDED
namespace hx
{
enum {
CompareAsInt,
CompareAsInt64,
CompareAsDouble,
CompareAsString,
CompareAsDynamic,
};
template <typename T>
struct CompareTraits
{
enum { type = (int)CompareAsDynamic };
inline static int toInt(Dynamic inValue) { return inValue; }
inline static double toDouble(Dynamic inValue) { return inValue; }
inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
inline static String toString(Dynamic inValue) { return inValue; }
inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
inline static int getDynamicCompareType(const Dynamic &inValue)
{
if (!inValue.mPtr)
return CompareAsDynamic;
switch(inValue->__GetType())
{
case vtInt: case vtBool: return CompareAsInt;
case vtInt64: return CompareAsInt64;
case vtFloat: return CompareAsDouble;
case vtString: return CompareAsString;
default: return CompareAsDynamic;
}
}
inline static bool isNull(const Dynamic &inValue) { return !inValue.mPtr; }
};
template <>
struct CompareTraits<null>
{
enum { type = (int)CompareAsDynamic };
inline static int toInt(const null &inValue) { return 0; }
inline static double toDouble(const null & inValue) { return 0; }
inline static cpp::Int64 toInt64(const null & inValue) { return 0; }
inline static String toString(const null & inValue) { return String(); }
inline static hx::Object *toObject(const null & inValue) { return 0; }
inline static int getDynamicCompareType(const null &) { return type; }
inline static bool isNull(const null &) { return true; }
};
template <>
struct CompareTraits<signed int>
{
enum { type = (int)CompareAsInt };
inline static int toInt(int inValue) { return inValue; }
inline static double toDouble(int inValue) { return inValue; }
inline static cpp::Int64 toInt64(int inValue) { return inValue; }
inline static String toString(int inValue) { return String(); }
inline static hx::Object *toObject(int inValue) { return 0; }
inline static int getDynamicCompareType(int) { return type; }
inline static bool isNull(int) { return false; }
};
template <>
struct CompareTraits<unsigned int>
{
enum { type = (int)CompareAsInt };
// Return value is unsigned ...
inline static unsigned int toInt(unsigned int inValue) { return inValue; }
inline static double toDouble(unsigned int inValue) { return inValue; }
inline static cpp::Int64 toInt64(unsigned int inValue) { return inValue; }
inline static String toString(unsigned int inValue) { return String(); }
inline static hx::Object *toObject(unsigned int inValue) { return 0; }
inline static int getDynamicCompareType(int) { return type; }
inline static bool isNull(int) { return false; }
};
template <> struct CompareTraits<signed short> : public CompareTraits<int> { };
template <> struct CompareTraits<unsigned short> : public CompareTraits<int> { };
template <> struct CompareTraits<signed char> : public CompareTraits<int> { };
template <> struct CompareTraits<unsigned char> : public CompareTraits<int> { };
template <> struct CompareTraits<char> : public CompareTraits<int> { };
template <> struct CompareTraits<wchar_t> : public CompareTraits<int> { };
#if __cplusplus >= 201103L || defined(KORE_MICROSOFT)
template <> struct CompareTraits<char16_t> : public CompareTraits<int> { };
#endif
template <>
struct CompareTraits<double>
{
enum { type = (int)CompareAsDouble };
inline static int toInt(double inValue) { return inValue; }
inline static double toDouble(double inValue) { return inValue; }
inline static cpp::Int64 toInt64(double inValue) { return inValue; }
inline static String toString(double inValue) { return String(); }
inline static hx::Object *toObject(double inValue) { return 0; }
inline static int getDynamicCompareType(const double &) { return type; }
inline static bool isNull(const double &) { return false; }
};
template <> struct CompareTraits<float> : public CompareTraits<double> { };
template <>
struct CompareTraits<cpp::Int64>
{
enum { type = (int)CompareAsInt64 };
inline static int toInt(cpp::Int64 inValue) { return (int)inValue; }
inline static double toDouble(cpp::Int64 inValue) { return inValue; }
inline static cpp::Int64 toInt64(cpp::Int64 inValue) { return inValue; }
inline static String toString(cpp::Int64 inValue) { return String(); }
inline static hx::Object *toObject(cpp::Int64 inValue) { return 0; }
inline static int getDynamicCompareType(cpp::Int64) { return type; }
inline static bool isNull(cpp::Int64) { return false; }
};
template <>
struct CompareTraits<cpp::UInt64>
{
enum { type = (int)CompareAsInt64 };
inline static int toInt(cpp::UInt64 inValue) { return (int)inValue; }
inline static double toDouble(cpp::UInt64 inValue) { return inValue; }
// Return value is unsigned ...
inline static cpp::UInt64 toInt64(cpp::UInt64 inValue) { return inValue; }
inline static String toString(cpp::UInt64 inValue) { return String(); }
inline static hx::Object *toObject(cpp::UInt64 inValue) { return 0; }
inline static int getDynamicCompareType(cpp::UInt64) { return type; }
inline static bool isNull(cpp::UInt64) { return false; }
};
template <>
struct CompareTraits< String >
{
enum { type = (int)CompareAsString };
inline static int toInt(const String &) { return 0; }
inline static double toDouble(const String &) { return 0; }
inline static cpp::Int64 toInt64(const String &) { return 0; }
inline static String toString(const String &inValue ) { return inValue; }
inline static hx::Object *toObject(const String &inValue) { return Dynamic(inValue).mPtr; }
inline static int getDynamicCompareType(const String &) { return type; }
inline static bool isNull(const String &inValue) { return !inValue.raw_ptr(); }
};
template <>
struct CompareTraits< cpp::Variant >
{
enum { type = (int)CompareAsDynamic };
// Might ne a
inline static int toInt(const cpp::Variant &inValue) { return inValue; }
inline static double toDouble(const cpp::Variant &inValue) { return inValue; }
inline static cpp::Int64 toInt64(const cpp::Variant &inValue) { return inValue; }
inline static String toString(const cpp::Variant &inValue ) { return inValue; }
inline static hx::Object *toObject(const cpp::Variant &inValue) {
if (inValue.type==cpp::Variant::typeObject)
return inValue.valObject;
return 0;
}
inline static int getDynamicCompareType(const cpp::Variant &inValue)
{
switch(inValue.type)
{
case cpp::Variant::typeInt: case cpp::Variant::typeBool: return CompareAsInt;
case cpp::Variant::typeInt64: return CompareAsInt64;
case cpp::Variant::typeDouble: return CompareAsDouble;
case cpp::Variant::typeString: return CompareAsString;
case cpp::Variant::typeObject:
{
if (!inValue.valObject)
return CompareAsDynamic;
switch(inValue.valObject->__GetType())
{
case vtInt: case vtBool: return CompareAsInt;
case vtInt64: return CompareAsInt64;
case vtFloat: return CompareAsDouble;
case vtString: return CompareAsString;
default: return CompareAsDynamic;
}
}
default:
return CompareAsDynamic;
}
}
inline static bool isNull(const cpp::Variant &inValue) { return inValue.isNull(); }
};
template <typename T>
struct CompareTraits< cpp::Pointer<T> >
{
enum { type = (int)CompareAsDynamic };
inline static int toInt(Dynamic inValue) { return inValue; }
inline static double toDouble(Dynamic inValue) { return inValue; }
inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
inline static String toString(Dynamic inValue) { return inValue; }
inline static hx::Object *toObject(Dynamic inValue) { return inValue.mPtr; }
inline static int getDynamicCompareType(const Dynamic &inValue)
{
return CompareAsDynamic;
}
inline static bool isNull(const cpp::Pointer<T> &inValue) { return !inValue.ptr; }
};
template <typename T>
struct CompareTraits< T * >
{
enum { type = (int)CompareAsInt64 };
inline static int toInt(T * inValue) { return 0; }
inline static double toDouble(T * inValue) { return 0; }
inline static cpp::Int64 toInt64(T * inValue) { return (cpp::Int64)inValue; }
inline static String toString(T * inValue) { return String(); }
inline static hx::Object *toObject(T * inValue) { return 0; }
inline static int getDynamicCompareType(T * inValue)
{
return CompareAsInt64;
}
inline static bool isNull(T *inValue) { return !inValue; }
};
template<typename T1>
hx::Object *GetExistingObject(const T1 &v1)
{
typedef CompareTraits<T1> traits1;
return traits1::toObject(v1);
}
template<typename T1>
bool IsNull(const T1 &v1)
{
typedef CompareTraits<T1> traits1;
return traits1::isNull(v1);
}
template<typename T1>
bool IsNotNull(const T1 &v1)
{
typedef CompareTraits<T1> traits1;
return !traits1::isNull(v1);
}
template<bool LESS, bool EQ, typename T1, typename T2>
inline bool TestLessEq(const T1 &v1, const T2 &v2)
{
typedef CompareTraits<T1> traits1;
typedef CompareTraits<T2> traits2;
if (traits1::type==(int)CompareAsInt && traits2::type==(int)CompareAsInt)
{
return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
traits1::toInt(v1) < traits2::toInt(v2) ) :
( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
traits1::toInt(v1) != traits2::toInt(v2) );
}
else if (traits1::type<=(int)CompareAsInt64 && traits2::type<=(int)CompareAsInt64)
{
return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
traits1::toInt64(v1) < traits2::toInt64(v2) ) :
( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
traits1::toInt64(v1) != traits2::toInt64(v2) );
}
else if (traits1::type<=(int)CompareAsDouble && traits2::type<=(int)CompareAsDouble)
{
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
traits1::toDouble(v1) != traits2::toDouble(v2) );
}
else if (traits1::type==(int)CompareAsString && traits2::type==(int)CompareAsString)
{
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
traits1::toString(v1) < traits2::toString(v2) ) :
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
traits1::toString(v1) != traits2::toString(v2) );
}
else if (traits1::type<=(int)CompareAsString && traits2::type<=(int)CompareAsString)
{
// String with a number...
return false;
}
else if (traits1::type==(int)CompareAsString || traits2::type==(int)CompareAsString)
{
// String with a object...
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
traits1::toString(v1) < traits2::toString(v2) ) :
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
traits1::toString(v1) != traits2::toString(v2) );
}
else if (traits1::type<=(int)CompareAsDouble || traits2::type<=(int)CompareAsDouble)
{
// numeric with a object...
// null can only be equal to null...
bool n1 = traits1::isNull(v1);
bool n2 = traits2::isNull(v2);
if (n1 || n2)
return EQ ? n1==n2 : !LESS && n1!=n2/* false,false = not equal*/;
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
traits1::toDouble(v1) != traits2::toDouble(v2) );
}
else
{
// Dynamic compare.
// This time, one or both types are calculated at run time
// Check null/not null compare
bool n1 = traits1::isNull(v1);
bool n2 = traits2::isNull(v2);
if (n1 || n2)
return EQ ? n1==n2 : !LESS && n1!=n2 /* false,false = not equal*/;
int t1 = traits1::getDynamicCompareType(v1);
int t2 = traits2::getDynamicCompareType(v2);
if (t1==(int)CompareAsInt && t2==(int)CompareAsInt)
{
return LESS ? ( EQ ? traits1::toInt(v1) <= traits2::toInt(v2) :
traits1::toInt(v1) < traits2::toInt(v2) ) :
( EQ ? traits1::toInt(v1) == traits2::toInt(v2) :
traits1::toInt(v1) != traits2::toInt(v2) );
}
else if (t1<=(int)CompareAsInt64 && t2<=(int)CompareAsInt64)
{
return LESS ? ( EQ ? traits1::toInt64(v1) <= traits2::toInt64(v2) :
traits1::toInt64(v1) < traits2::toInt64(v2) ) :
( EQ ? traits1::toInt64(v1) == traits2::toInt64(v2) :
traits1::toInt64(v1) != traits2::toInt64(v2) );
}
else if (t1<=(int)CompareAsDouble && t2<=(int)CompareAsDouble)
{
return LESS ? ( EQ ? traits1::toDouble(v1) <= traits2::toDouble(v2) :
traits1::toDouble(v1) < traits2::toDouble(v2) ) :
( EQ ? traits1::toDouble(v1) == traits2::toDouble(v2) :
traits1::toDouble(v1) != traits2::toDouble(v2) );
}
else if (t1==(int)CompareAsString && t2==(int)CompareAsString)
{
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
traits1::toString(v1) < traits2::toString(v2) ) :
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
traits1::toString(v1) != traits2::toString(v2) );
}
else if (t1<=(int)CompareAsString && t2<=(int)CompareAsString)
{
// String with a number...
return false;
}
else if (t1==(int)CompareAsString || t2==(int)CompareAsString)
{
// String with a object...
return LESS ? ( EQ ? traits1::toString(v1) <= traits2::toString(v2) :
traits1::toString(v1) < traits2::toString(v2) ) :
( EQ ? traits1::toString(v1) == traits2::toString(v2) :
traits1::toString(v1) != traits2::toString(v2) );
}
else if (t1<=(int)CompareAsDouble || t2<=(int)CompareAsDouble)
{
// numeric with a object only works for not-equal
return !LESS && !EQ;
}
else
{
// Object with Object
hx::Object *o1 = traits1::toObject(v1);
hx::Object *o2 = traits2::toObject(v2);
int diff = o1->__Compare(o2);
return LESS ? ( EQ ? diff <= 0 :
diff < 0 ) :
( EQ ? diff == 0 :
diff != 0 );
}
}
}
template<typename T1, typename T2>
bool IsEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,true,T1,T2>(v1,v2); }
template<typename T1, typename T2>
bool IsNotEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,false,T1,T2>(v1,v2); }
template<typename T1, typename T2>
bool IsLess(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T1,T2>(v1,v2); }
template<typename T1, typename T2>
bool IsLessEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T1,T2>(v1,v2); }
template<typename T1, typename T2>
bool IsGreater(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T2,T1>(v2,v1); }
template<typename T1, typename T2>
bool IsGreaterEq(const T1 &v1, const T2 &v2) { return TestLessEq<true,true,T2,T1>(v2,v1); }
template<typename T1, typename T2>
bool IsPointerEq(const T1 &v1, const T2 &v2)
{
return GetExistingObject(v1) == GetExistingObject(v2);
}
template<typename T1, typename T2>
bool IsPointerNotEq(const T1 &v1, const T2 &v2)
{
return GetExistingObject(v1) != GetExistingObject(v2);
}
template<typename T1, typename T2>
bool IsInstanceEq(const T1 &v1, const T2 &v2)
{
hx::Object *p1 = GetExistingObject(v1);
hx::Object *p2 = GetExistingObject(v2);
if (p1==p2)
return true;
if (!p1 || !p2)
return false;
return !p1->__Compare(p2);
}
template<typename T1, typename T2>
bool IsInstanceNotEq(const T1 &v1, const T2 &v2)
{
hx::Object *p1 = GetExistingObject(v1);
hx::Object *p2 = GetExistingObject(v2);
if (p1==p2)
return false;
if (!p1 || !p2)
return true;
return p1->__Compare(p2);
}
}
#endif

1138
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.h Normal file
View File

File diff suppressed because it is too large Load Diff

195
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Macros.tpl Normal file
View File

@ -0,0 +1,195 @@
#ifndef HX_MACROS_H
#define HX_MACROS_H
// --- Functions and their parameters ----
::foreach PARAMS::
#define HX_ARR_LIST::ARG:: ::ARR_LIST::::end::
::foreach PARAMS::
#define HX_DYNAMIC_ARG_LIST::ARG:: ::DYNAMIC_ARG_LIST::::end::
::foreach PARAMS::
#define HX_ARG_LIST::ARG:: ::ARG_LIST::::end::
#define HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj) \
{ \
ret reinterpret_cast<class *>(inObj)->func(); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateMemberFunction0(#func,this,__##class##func); \
}
#define HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, dynamic_arg_list) \
{ \
ret reinterpret_cast<class *>(inObj)->func(arg_list); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateMemberFunction##N(#func,this,__##class##func); \
}
#define HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
static ::NS::Dynamic __##class##func(::hxNS::Object *inObj, const Array< ::NS::Dynamic> &inArgs) \
{ \
ret reinterpret_cast<class *>(inObj)->func(array_list); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateMemberFunctionVar(#func,this,__##class##func,N); \
}
#define DELEGATE_0(ret,func) ret func() { return mDelegate->func(); }
#define CDELEGATE_0(ret,func) ret func() const { return mDelegate->func(); }
#define DELEGATE_1(ret,func,arg1) ret func(arg1 _a1) { return mDelegate->func(_a1); }
#define CDELEGATE_1(ret,func,arg1) ret func(arg1 _a1) const { return mDelegate->func(_a1); }
#define DELEGATE_2(ret,func,arg1,arg2) ret func(arg1 _a1,arg2 _a2) { return mDelegate->func(_a1,_a2); }
#define HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
::NS::Dynamic func##_dyn(dynamic_arg_list);
#define STATIC_HX_DECLARE_DYNAMIC_FUNC(func,dynamic_arg_list) \
static ::NS::Dynamic func##_dyn(dynamic_arg_list);
::foreach PARAMS::
::if (ARG>0)::::if (ARG<6)::
#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
::else::
#define HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
::end::
::end::::end::
#define STATIC_HX_DEFINE_DYNAMIC_FUNC0(class,func,ret) \
static ::NS::Dynamic __##class##func() \
{ \
ret class::func(); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateStaticFunction0(#func,__##class##func); \
}
#define STATIC_HX_DEFINE_DYNAMIC_FUNC(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
static ::NS::Dynamic __##class##func(dynamic_arg_list) \
{ \
ret class::func(arg_list); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateStaticFunction##N(#func,__##class##func); \
}
#define STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,N,func,ret,array_list,dynamic_arg_list,arg_list) \
static ::NS::Dynamic __##class##func(const Array< ::NS::Dynamic> &inArgs) \
{ \
ret class::func(array_list); return ::NS::Dynamic(); \
}; \
::NS::Dynamic class::func##_dyn() \
{\
return ::hxNS::CreateStaticFunctionVar(#func,__##class##func,N); \
}
::foreach PARAMS::
::if (ARG>0)::::if (ARG<6)::
#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
STATIC_HX_DEFINE_DYNAMIC_FUNC(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
::else::
#define STATIC_HX_DEFINE_DYNAMIC_FUNC::ARG::(class,func,ret) \
STATIC_HX_DEFINE_DYNAMIC_FUNC_EXTRA(class,::ARG::,func,ret,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)
::end::
::end::::end::
#define HX_DYNAMIC_CALL(ret,func,array_args,dyn_arg_list,arg_list) \
::NS::Dynamic __Run(const Array< ::NS::Dynamic> &inArgs) { ret func( array_args ); return null();} \
::NS::Dynamic __run(dyn_arg_list) { ret func( arg_list ); return null();}
::foreach PARAMS::
#define HX_DYNAMIC_CALL::ARG::(ret,func) HX_DYNAMIC_CALL(ret,func,HX_ARR_LIST::ARG::,HX_DYNAMIC_ARG_LIST::ARG::,HX_ARG_LIST::ARG::)::end::
#define HX_BEGIN_DEFAULT_FUNC(name,t0) \
namespace { \
struct name : public ::hxNS::Object { int __GetType() const { return vtFunction; } \
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
::hxNS::ObjectPtr<t0> __this; \
name(::hxNS::ObjectPtr<t0> __0 = null()) : __this(__0) {} \
void __Mark(::hxNS::MarkContext *__inCtx) { HX_MARK_MEMBER(__this); } \
void __Visit(::hxNS::VisitContext *__inCtx) { HX_VISIT_MEMBER(__this); }
#define HX_END_DEFAULT_FUNC \
}
#define HXARGC(x) int __ArgCount() const { return x; }
#define HX_BEGIN_LOCAL_FUNC_S0(SUPER,name) \
struct name : public SUPER { \
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); } \
void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); } \
name() {}
::foreach LOCALS::
#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
struct name : public SUPER { \
HX_IS_INSTANCE_OF enum { _hx_ClassId = ::hxNS::clsIdClosure }; \
::TYPE_DECL::; \
void __Mark(::hxNS::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
void __Visit(::hxNS::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
#if (HXCPP_API_LEVEL>=330)
#define HX_LOCAL_RUN _hx_run
#else
#define HX_LOCAL_RUN run
#endif
#define HX_END_LOCAL_FUNC0(ret) HX_DYNAMIC_CALL0(ret, HX_LOCAL_RUN ) };
::foreach LOCALS::
#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
// For compatibility until next version of haxe is released
#define HX_BEGIN_LOCAL_FUNC0(name) \
HX_BEGIN_LOCAL_FUNC_S0(::hxNS::LocalFunc,name)
::foreach LOCALS::
#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
HX_BEGIN_LOCAL_FUNC_S::ARG::(::hxNS::LocalFunc,name,::TYPE_ARGS::)::end::
#define HX_DECLARE_DYNAMIC_FUNCTIONS \
::foreach PARAMS:: ::if (ARG<6)::::else:: ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
::end:: ::end::
#define HX_DECLARE_VARIANT_FUNCTIONS \
::foreach PARAMS:: ::if (ARG<6):: inline ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
::else:: ::NS::Dynamic operator()(::DYNAMIC_ARG_LIST::); \
::end:: ::end::
#define HX_IMPLEMENT_INLINE_VARIANT_FUNCTIONS \
::foreach PARAMS:: ::if (ARG<6):: ::NS::Dynamic Variant::NS::operator()(::DYNAMIC_ARG_LIST::) { CheckFPtr(); return valObject->__run(::ARG_LIST::); } \
::end:: ::end::
#endif

355
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosFixed.h Normal file
View File

@ -0,0 +1,355 @@
#ifndef MACROS_FIXED_H
#define MACROS_FIXED_H
// ---- Forward Declare ---------------
#define HX_DECLARE_CLASS0(klass) \
class klass##_obj; \
typedef ::hx::ObjectPtr<klass##_obj> klass;
#define HX_DECLARE_CLASS1(ns1,klass) namespace ns1 { HX_DECLARE_CLASS0(klass) }
#define HX_DECLARE_CLASS2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_CLASS1(ns1,klass) }
#define HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_CLASS2(ns2,ns1,klass) }
#define HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_CLASS3(ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_CLASS4(ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_CLASS5(ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_CLASS6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_CLASS7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_CLASS8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns10 { HX_DECLARE_CLASS9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns11 { HX_DECLARE_CLASS10(ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns12 { HX_DECLARE_CLASS11(ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns13 { HX_DECLARE_CLASS12(ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns14 { HX_DECLARE_CLASS13(ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns15 { HX_DECLARE_CLASS14(ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns16 { HX_DECLARE_CLASS15(ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns17 { HX_DECLARE_CLASS16(ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns18 { HX_DECLARE_CLASS17(ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns19 { HX_DECLARE_CLASS18(ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_CLASS20(ns20,ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns20 { HX_DECLARE_CLASS19(ns19,ns18,ns17,ns16,ns15,ns14,ns13,ns12,ns11,ns10,ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
// ---- Enum ----------------------
#if (HXCPP_API_LEVEL >= 330)
#define HX_DEFINE_CREATE_ENUM(enum_obj) \
static ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
{ \
int count = enum_obj::__FindArgCount(inName); \
int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
::Dynamic result; \
if (!enum_obj::__GetStatic(inName,result,::hx::paccDynamic)) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
if (args==0) return result; \
return result->__Run(inArgs); \
}
#else
#define HX_DEFINE_CREATE_ENUM(enum_obj) \
static ::Dynamic Create##enum_obj(::String inName,::hx::DynamicArray inArgs) \
{ \
int idx = enum_obj::__FindIndex(inName); \
if (idx<0) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_CONSTRUCTOR(#enum_obj, inName)); \
int count = enum_obj::__FindArgCount(inName); \
int args = inArgs.GetPtr() ? inArgs.__length() : 0; \
if (args!=count) __hxcpp_dbg_checkedThrow(HX_INVALID_ENUM_ARG_COUNT(#enum_obj, inName, count, args)); \
::Dynamic result =(new enum_obj())->__Field(inName,HX_PROP_DYNAMIC); \
if (args==0 || !result.mPtr) return result; \
return result->__Run(inArgs); \
}
#endif
// ---- Fields ----------------------
#if (HXCPP_API_LEVEL<331)
#define HX_DO_RTTI_BASE \
bool __Is(::hx::Object *inObj) const { return dynamic_cast<OBJ_ *>(inObj)!=0; }
#else
#define HX_DO_RTTI_BASE
#endif
#if (HXCPP_API_LEVEL>331)
#define HX_IS_INSTANCE_OF bool _hx_isInstanceOf(int inClassId) { return inClassId==1 || inClassId==(int)_hx_ClassId; }
#else
#define HX_IS_INSTANCE_OF
#endif
#define HX_DO_RTTI_ALL \
HX_DO_RTTI_BASE \
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
inline static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
inline operator super *() { return this; }
#define HX_DO_RTTI \
HX_DO_RTTI_ALL \
::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp); \
::hx::Val __SetField(const ::String &inString,const ::hx::Val &inValue, ::hx::PropertyAccess inCallProp); \
void __GetFields(Array< ::String> &outFields);
#define HX_DO_INTERFACE_RTTI \
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; } \
static void __register();
#define HX_DO_ENUM_RTTI_INTERNAL \
HX_DO_RTTI_BASE \
::hx::Val __Field(const ::String &inString, ::hx::PropertyAccess inCallProp); \
static int __FindIndex(::String inName); \
static int __FindArgCount(::String inName);
#define HX_DO_ENUM_RTTI \
HX_DO_ENUM_RTTI_INTERNAL \
static ::hx::ObjectPtr< ::hx::Class_obj> __mClass; \
::hx::ObjectPtr< ::hx::Class_obj > __GetClass() const { return __mClass; } \
static ::hx::ObjectPtr< ::hx::Class_obj> &__SGetClass() { return __mClass; }
#define HX_DECLARE_IMPLEMENT_DYNAMIC ::Dynamic __mDynamicFields; \
::Dynamic *__GetFieldMap() { return &__mDynamicFields; } \
bool __HasField(const String &inString) \
{ return ::hx::FieldMapHas(&__mDynamicFields,inString) || super::__HasField(inString); }
#define HX_INIT_IMPLEMENT_DYNAMIC
#define HX_MARK_DYNAMIC HX_MARK_MEMBER(__mDynamicFields)
#ifdef HX_VISIT_ALLOCS
#define HX_VISIT_DYNAMIC HX_VISIT_MEMBER(__mDynamicFields);
#else
#define HX_VISIT_DYNAMIC do { } while (0);
#endif
#define HX_CHECK_DYNAMIC_GET_FIELD(inName) \
{ ::Dynamic d; if (::hx::FieldMapGet(&__mDynamicFields,inName,d)) return d; }
#define HX_CHECK_DYNAMIC_GET_INT_FIELD(inID) \
{ ::Dynamic d; if (::hx::FieldMapGet(&__mDynamicFields,inID,d)) return d; }
#ifdef HXCPP_GC_GENERATIONAL
#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(this,&__mDynamicFields,inName,inValue)
#else
#define HX_DYNAMIC_SET_FIELD(inName,inValue) ::hx::FieldMapSet(&__mDynamicFields,inName,inValue)
#endif
#define HX_APPEND_DYNAMIC_FIELDS(outFields) ::hx::FieldMapAppendFields(&__mDynamicFields,outFields)
// ---- Main ---------------
namespace hx {
HXCPP_EXTERN_CLASS_ATTRIBUTES void SetTopOfStack(int *inTopOfStack,bool);
}
#define HX_TOP_OF_STACK \
int t0 = 99; \
::hx::SetTopOfStack(&t0,false);
#ifdef __GNUC__
#define EXPORT_EXTRA __attribute__ ((visibility("default")))
#else
#define EXPORT_EXTRA __declspec(dllexport)
#endif
#ifdef HX_DECLARE_MAIN
#ifdef HXCPP_DLL_IMPORT
#define HX_BEGIN_MAIN \
extern "C" { \
EXPORT_EXTRA void __main__() { \
__boot_all();
#define HX_END_MAIN \
} \
}
#elif defined(HX_ANDROID)
#ifdef HXCPP_EXE_LINK
#define HX_BEGIN_MAIN \
\
int main(int argc,char **argv){ \
HX_TOP_OF_STACK \
::hx::Boot(); \
try{ \
__boot_all();
#define HX_END_MAIN \
} \
catch ( ::Dynamic e){ \
__hx_dump_stack(); \
printf("Error : %s\n",e->toString().__CStr()); \
return -1; \
} \
return 0; \
}
#else
// Java Main....
#include <jni.h>
#include <hx/Thread.h>
#include <android/log.h>
#define HX_BEGIN_MAIN \
extern "C" EXPORT_EXTRA void hxcpp_main() { \
HX_TOP_OF_STACK \
try { \
::hx::Boot(); \
__boot_all();
#define HX_END_MAIN \
} catch ( ::Dynamic e) { \
__hx_dump_stack(); \
__android_log_print(ANDROID_LOG_ERROR, "Exception", "%s", e->toString().__CStr()); \
}\
::hx::SetTopOfStack((int *)0,true); \
} \
\
extern "C" EXPORT_EXTRA JNIEXPORT void JNICALL Java_org_haxe_HXCPP_main(JNIEnv * env) \
{ hxcpp_main(); }
#endif
#elif defined(HX_WINRT)
#include <Roapi.h>
#define HX_BEGIN_MAIN \
[ Platform::MTAThread ] \
int main(Platform::Array<Platform::String^>^) \
{ \
HX_TOP_OF_STACK \
RoInitialize(RO_INIT_MULTITHREADED); \
::hx::Boot(); \
try{ \
__boot_all();
#define HX_END_MAIN \
} \
catch ( ::Dynamic e){ \
__hx_dump_stack(); \
return -1; \
} \
return 0; \
}
#elif defined(HX_WIN_MAIN)
#ifdef HAVE_WINDOWS_H
#define HX_BEGIN_MAIN \
int __stdcall WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) \
{ \
HX_TOP_OF_STACK \
::hx::Boot(); \
try{ \
__boot_all();
#else
#define HX_BEGIN_MAIN \
extern "C" int __stdcall MessageBoxA(void *,const char *,const char *,int); \
\
int __stdcall WinMain( void * hInstance, void * hPrevInstance, const char *lpCmdLine, int nCmdShow) \
{ \
HX_TOP_OF_STACK \
::hx::Boot(); \
try{ \
__boot_all();
#endif
#define HX_END_MAIN \
} \
catch ( ::Dynamic e){ \
__hx_dump_stack(); \
MessageBoxA(0, e->toString().__CStr(), "Error", 0); \
return -1; \
} \
return 0; \
}
#elif defined(TIZEN)
#define HX_BEGIN_MAIN \
\
extern "C" EXPORT_EXTRA int OspMain (int argc, char* pArgv[]){ \
HX_TOP_OF_STACK \
::hx::Boot(); \
try{ \
__boot_all();
#define HX_END_MAIN \
} \
catch ( ::Dynamic e){ \
__hx_dump_stack(); \
printf("Error : %s\n",e->toString().__CStr()); \
return -1; \
} \
return 0; \
}
#else
// Console Main ...
#define HX_BEGIN_MAIN \
\
int main(int argc,char **argv){ \
HX_TOP_OF_STACK \
::hx::Boot(); \
try{ \
__boot_all();
#define HX_END_MAIN \
} \
catch ( ::Dynamic e){ \
__hx_dump_stack(); \
printf("Error : %s\n",e->toString().__CStr()); \
return -1; \
} \
return 0; \
}
#endif
#endif // HX_DECLARE_MAIN
// Run as library
#define HX_BEGIN_LIB_MAIN \
extern "C" {\
\
void __hxcpp_lib_main() \
{ \
HX_TOP_OF_STACK \
::hx::Boot(); \
__boot_all();
#define HX_END_LIB_MAIN \
} }
#endif

406
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.h Normal file
View File

@ -0,0 +1,406 @@
// ## ## ## ## #### ## ## ## ## ## #### ##
// ## ## ## ## ## ## ## ### ## ## ### ## ## ##
// ## ## ## ###### ###### ###### ## ###### ## ### ##
// ## ## ## ## ## ## ## ## ### ## ## ### ## ##
// ## ## ## ## ## ## ## ## ## ## ## #### ##
// DO NOT EDIT
// This file is generated from the .tpl file
#ifndef HX_MACROS_JUMBO_H
#define HX_MACROS_JUMBO_H
#define HX_BEGIN_LOCAL_FUNC_S20(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19) {}
#define HX_BEGIN_LOCAL_FUNC_S21(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20) {}
#define HX_BEGIN_LOCAL_FUNC_S22(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21) {}
#define HX_BEGIN_LOCAL_FUNC_S23(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22) {}
#define HX_BEGIN_LOCAL_FUNC_S24(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23) {}
#define HX_BEGIN_LOCAL_FUNC_S25(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24) {}
#define HX_BEGIN_LOCAL_FUNC_S26(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25) {}
#define HX_BEGIN_LOCAL_FUNC_S27(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26) {}
#define HX_BEGIN_LOCAL_FUNC_S28(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27) {}
#define HX_BEGIN_LOCAL_FUNC_S29(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28) {}
#define HX_BEGIN_LOCAL_FUNC_S30(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29) {}
#define HX_BEGIN_LOCAL_FUNC_S31(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30) {}
#define HX_BEGIN_LOCAL_FUNC_S32(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31) {}
#define HX_BEGIN_LOCAL_FUNC_S33(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32) {}
#define HX_BEGIN_LOCAL_FUNC_S34(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33) {}
#define HX_BEGIN_LOCAL_FUNC_S35(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34) {}
#define HX_BEGIN_LOCAL_FUNC_S36(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35) {}
#define HX_BEGIN_LOCAL_FUNC_S37(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36) {}
#define HX_BEGIN_LOCAL_FUNC_S38(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37) {}
#define HX_BEGIN_LOCAL_FUNC_S39(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38) {}
#define HX_BEGIN_LOCAL_FUNC_S40(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39) {}
#define HX_BEGIN_LOCAL_FUNC_S41(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40) {}
#define HX_BEGIN_LOCAL_FUNC_S42(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41) {}
#define HX_BEGIN_LOCAL_FUNC_S43(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42) {}
#define HX_BEGIN_LOCAL_FUNC_S44(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43) {}
#define HX_BEGIN_LOCAL_FUNC_S45(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44) {}
#define HX_BEGIN_LOCAL_FUNC_S46(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45) {}
#define HX_BEGIN_LOCAL_FUNC_S47(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46) {}
#define HX_BEGIN_LOCAL_FUNC_S48(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47) {}
#define HX_BEGIN_LOCAL_FUNC_S49(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48) {}
#define HX_BEGIN_LOCAL_FUNC_S50(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49) {}
#define HX_BEGIN_LOCAL_FUNC_S51(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50) {}
#define HX_BEGIN_LOCAL_FUNC_S52(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51) {}
#define HX_BEGIN_LOCAL_FUNC_S53(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52) {}
#define HX_BEGIN_LOCAL_FUNC_S54(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53) {}
#define HX_BEGIN_LOCAL_FUNC_S55(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54) {}
#define HX_BEGIN_LOCAL_FUNC_S56(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55) {}
#define HX_BEGIN_LOCAL_FUNC_S57(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56) {}
#define HX_BEGIN_LOCAL_FUNC_S58(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57) {}
#define HX_BEGIN_LOCAL_FUNC_S59(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58) {}
#define HX_BEGIN_LOCAL_FUNC_S60(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59) {}
#define HX_BEGIN_LOCAL_FUNC_S61(SUPER,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
struct name : public SUPER { \
t0 v0;t1 v1;t2 v2;t3 v3;t4 v4;t5 v5;t6 v6;t7 v7;t8 v8;t9 v9;t10 v10;t11 v11;t12 v12;t13 v13;t14 v14;t15 v15;t16 v16;t17 v17;t18 v18;t19 v19;t20 v20;t21 v21;t22 v22;t23 v23;t24 v24;t25 v25;t26 v26;t27 v27;t28 v28;t29 v29;t30 v30;t31 v31;t32 v32;t33 v33;t34 v34;t35 v35;t36 v36;t37 v37;t38 v38;t39 v39;t40 v40;t41 v41;t42 v42;t43 v43;t44 v44;t45 v45;t46 v46;t47 v47;t48 v48;t49 v49;t50 v50;t51 v51;t52 v52;t53 v53;t54 v54;t55 v55;t56 v56;t57 v57;t58 v58;t59 v59;t60 v60; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); HX_MARK_MEMBER(v0); HX_MARK_MEMBER(v1); HX_MARK_MEMBER(v2); HX_MARK_MEMBER(v3); HX_MARK_MEMBER(v4); HX_MARK_MEMBER(v5); HX_MARK_MEMBER(v6); HX_MARK_MEMBER(v7); HX_MARK_MEMBER(v8); HX_MARK_MEMBER(v9); HX_MARK_MEMBER(v10); HX_MARK_MEMBER(v11); HX_MARK_MEMBER(v12); HX_MARK_MEMBER(v13); HX_MARK_MEMBER(v14); HX_MARK_MEMBER(v15); HX_MARK_MEMBER(v16); HX_MARK_MEMBER(v17); HX_MARK_MEMBER(v18); HX_MARK_MEMBER(v19); HX_MARK_MEMBER(v20); HX_MARK_MEMBER(v21); HX_MARK_MEMBER(v22); HX_MARK_MEMBER(v23); HX_MARK_MEMBER(v24); HX_MARK_MEMBER(v25); HX_MARK_MEMBER(v26); HX_MARK_MEMBER(v27); HX_MARK_MEMBER(v28); HX_MARK_MEMBER(v29); HX_MARK_MEMBER(v30); HX_MARK_MEMBER(v31); HX_MARK_MEMBER(v32); HX_MARK_MEMBER(v33); HX_MARK_MEMBER(v34); HX_MARK_MEMBER(v35); HX_MARK_MEMBER(v36); HX_MARK_MEMBER(v37); HX_MARK_MEMBER(v38); HX_MARK_MEMBER(v39); HX_MARK_MEMBER(v40); HX_MARK_MEMBER(v41); HX_MARK_MEMBER(v42); HX_MARK_MEMBER(v43); HX_MARK_MEMBER(v44); HX_MARK_MEMBER(v45); HX_MARK_MEMBER(v46); HX_MARK_MEMBER(v47); HX_MARK_MEMBER(v48); HX_MARK_MEMBER(v49); HX_MARK_MEMBER(v50); HX_MARK_MEMBER(v51); HX_MARK_MEMBER(v52); HX_MARK_MEMBER(v53); HX_MARK_MEMBER(v54); HX_MARK_MEMBER(v55); HX_MARK_MEMBER(v56); HX_MARK_MEMBER(v57); HX_MARK_MEMBER(v58); HX_MARK_MEMBER(v59); HX_MARK_MEMBER(v60); } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); HX_VISIT_MEMBER(v0); HX_VISIT_MEMBER(v1); HX_VISIT_MEMBER(v2); HX_VISIT_MEMBER(v3); HX_VISIT_MEMBER(v4); HX_VISIT_MEMBER(v5); HX_VISIT_MEMBER(v6); HX_VISIT_MEMBER(v7); HX_VISIT_MEMBER(v8); HX_VISIT_MEMBER(v9); HX_VISIT_MEMBER(v10); HX_VISIT_MEMBER(v11); HX_VISIT_MEMBER(v12); HX_VISIT_MEMBER(v13); HX_VISIT_MEMBER(v14); HX_VISIT_MEMBER(v15); HX_VISIT_MEMBER(v16); HX_VISIT_MEMBER(v17); HX_VISIT_MEMBER(v18); HX_VISIT_MEMBER(v19); HX_VISIT_MEMBER(v20); HX_VISIT_MEMBER(v21); HX_VISIT_MEMBER(v22); HX_VISIT_MEMBER(v23); HX_VISIT_MEMBER(v24); HX_VISIT_MEMBER(v25); HX_VISIT_MEMBER(v26); HX_VISIT_MEMBER(v27); HX_VISIT_MEMBER(v28); HX_VISIT_MEMBER(v29); HX_VISIT_MEMBER(v30); HX_VISIT_MEMBER(v31); HX_VISIT_MEMBER(v32); HX_VISIT_MEMBER(v33); HX_VISIT_MEMBER(v34); HX_VISIT_MEMBER(v35); HX_VISIT_MEMBER(v36); HX_VISIT_MEMBER(v37); HX_VISIT_MEMBER(v38); HX_VISIT_MEMBER(v39); HX_VISIT_MEMBER(v40); HX_VISIT_MEMBER(v41); HX_VISIT_MEMBER(v42); HX_VISIT_MEMBER(v43); HX_VISIT_MEMBER(v44); HX_VISIT_MEMBER(v45); HX_VISIT_MEMBER(v46); HX_VISIT_MEMBER(v47); HX_VISIT_MEMBER(v48); HX_VISIT_MEMBER(v49); HX_VISIT_MEMBER(v50); HX_VISIT_MEMBER(v51); HX_VISIT_MEMBER(v52); HX_VISIT_MEMBER(v53); HX_VISIT_MEMBER(v54); HX_VISIT_MEMBER(v55); HX_VISIT_MEMBER(v56); HX_VISIT_MEMBER(v57); HX_VISIT_MEMBER(v58); HX_VISIT_MEMBER(v59); HX_VISIT_MEMBER(v60); } \
name(t0 __0,t1 __1,t2 __2,t3 __3,t4 __4,t5 __5,t6 __6,t7 __7,t8 __8,t9 __9,t10 __10,t11 __11,t12 __12,t13 __13,t14 __14,t15 __15,t16 __16,t17 __17,t18 __18,t19 __19,t20 __20,t21 __21,t22 __22,t23 __23,t24 __24,t25 __25,t26 __26,t27 __27,t28 __28,t29 __29,t30 __30,t31 __31,t32 __32,t33 __33,t34 __34,t35 __35,t36 __36,t37 __37,t38 __38,t39 __39,t40 __40,t41 __41,t42 __42,t43 __43,t44 __44,t45 __45,t46 __46,t47 __47,t48 __48,t49 __49,t50 __50,t51 __51,t52 __52,t53 __53,t54 __54,t55 __55,t56 __56,t57 __57,t58 __58,t59 __59,t60 __60) : v0(__0),v1(__1),v2(__2),v3(__3),v4(__4),v5(__5),v6(__6),v7(__7),v8(__8),v9(__9),v10(__10),v11(__11),v12(__12),v13(__13),v14(__14),v15(__15),v16(__16),v17(__17),v18(__18),v19(__19),v20(__20),v21(__21),v22(__22),v23(__23),v24(__24),v25(__25),v26(__26),v27(__27),v28(__28),v29(__29),v30(__30),v31(__31),v32(__32),v33(__33),v34(__34),v35(__35),v36(__36),v37(__37),v38(__38),v39(__39),v40(__40),v41(__41),v42(__42),v43(__43),v44(__44),v45(__45),v46(__46),v47(__47),v48(__48),v49(__49),v50(__50),v51(__51),v52(__52),v53(__53),v54(__54),v55(__55),v56(__56),v57(__57),v58(__58),v59(__59),v60(__60) {}
#if (HXCPP_API_LEVEL>=330)
#define HX_LOCAL_RUN _hx_run
#else
#define HX_LOCAL_RUN run
#endif
#define HX_END_LOCAL_FUNC20(ret) HX_DYNAMIC_CALL20(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC21(ret) HX_DYNAMIC_CALL21(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC22(ret) HX_DYNAMIC_CALL22(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC23(ret) HX_DYNAMIC_CALL23(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC24(ret) HX_DYNAMIC_CALL24(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC25(ret) HX_DYNAMIC_CALL25(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC26(ret) HX_DYNAMIC_CALL26(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC27(ret) HX_DYNAMIC_CALL27(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC28(ret) HX_DYNAMIC_CALL28(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC29(ret) HX_DYNAMIC_CALL29(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC30(ret) HX_DYNAMIC_CALL30(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC31(ret) HX_DYNAMIC_CALL31(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC32(ret) HX_DYNAMIC_CALL32(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC33(ret) HX_DYNAMIC_CALL33(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC34(ret) HX_DYNAMIC_CALL34(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC35(ret) HX_DYNAMIC_CALL35(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC36(ret) HX_DYNAMIC_CALL36(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC37(ret) HX_DYNAMIC_CALL37(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC38(ret) HX_DYNAMIC_CALL38(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC39(ret) HX_DYNAMIC_CALL39(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC40(ret) HX_DYNAMIC_CALL40(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC41(ret) HX_DYNAMIC_CALL41(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC42(ret) HX_DYNAMIC_CALL42(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC43(ret) HX_DYNAMIC_CALL43(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC44(ret) HX_DYNAMIC_CALL44(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC45(ret) HX_DYNAMIC_CALL45(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC46(ret) HX_DYNAMIC_CALL46(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC47(ret) HX_DYNAMIC_CALL47(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC48(ret) HX_DYNAMIC_CALL48(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC49(ret) HX_DYNAMIC_CALL49(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC50(ret) HX_DYNAMIC_CALL50(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC51(ret) HX_DYNAMIC_CALL51(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC52(ret) HX_DYNAMIC_CALL52(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC53(ret) HX_DYNAMIC_CALL53(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC54(ret) HX_DYNAMIC_CALL54(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC55(ret) HX_DYNAMIC_CALL55(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC56(ret) HX_DYNAMIC_CALL56(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC57(ret) HX_DYNAMIC_CALL57(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC58(ret) HX_DYNAMIC_CALL58(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC59(ret) HX_DYNAMIC_CALL59(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC60(ret) HX_DYNAMIC_CALL60(ret, HX_LOCAL_RUN ) };
#define HX_END_LOCAL_FUNC61(ret) HX_DYNAMIC_CALL61(ret, HX_LOCAL_RUN ) };
// For compatibility until next version of haxe is released
#define HX_BEGIN_LOCAL_FUNC20(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19) \
HX_BEGIN_LOCAL_FUNC_S20(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19)
#define HX_BEGIN_LOCAL_FUNC21(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20) \
HX_BEGIN_LOCAL_FUNC_S21(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20)
#define HX_BEGIN_LOCAL_FUNC22(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21) \
HX_BEGIN_LOCAL_FUNC_S22(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21)
#define HX_BEGIN_LOCAL_FUNC23(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22) \
HX_BEGIN_LOCAL_FUNC_S23(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22)
#define HX_BEGIN_LOCAL_FUNC24(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23) \
HX_BEGIN_LOCAL_FUNC_S24(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23)
#define HX_BEGIN_LOCAL_FUNC25(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24) \
HX_BEGIN_LOCAL_FUNC_S25(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24)
#define HX_BEGIN_LOCAL_FUNC26(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25) \
HX_BEGIN_LOCAL_FUNC_S26(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25)
#define HX_BEGIN_LOCAL_FUNC27(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26) \
HX_BEGIN_LOCAL_FUNC_S27(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26)
#define HX_BEGIN_LOCAL_FUNC28(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27) \
HX_BEGIN_LOCAL_FUNC_S28(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27)
#define HX_BEGIN_LOCAL_FUNC29(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28) \
HX_BEGIN_LOCAL_FUNC_S29(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28)
#define HX_BEGIN_LOCAL_FUNC30(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29) \
HX_BEGIN_LOCAL_FUNC_S30(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29)
#define HX_BEGIN_LOCAL_FUNC31(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30) \
HX_BEGIN_LOCAL_FUNC_S31(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30)
#define HX_BEGIN_LOCAL_FUNC32(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31) \
HX_BEGIN_LOCAL_FUNC_S32(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31)
#define HX_BEGIN_LOCAL_FUNC33(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32) \
HX_BEGIN_LOCAL_FUNC_S33(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32)
#define HX_BEGIN_LOCAL_FUNC34(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33) \
HX_BEGIN_LOCAL_FUNC_S34(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33)
#define HX_BEGIN_LOCAL_FUNC35(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34) \
HX_BEGIN_LOCAL_FUNC_S35(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34)
#define HX_BEGIN_LOCAL_FUNC36(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35) \
HX_BEGIN_LOCAL_FUNC_S36(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35)
#define HX_BEGIN_LOCAL_FUNC37(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36) \
HX_BEGIN_LOCAL_FUNC_S37(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36)
#define HX_BEGIN_LOCAL_FUNC38(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37) \
HX_BEGIN_LOCAL_FUNC_S38(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37)
#define HX_BEGIN_LOCAL_FUNC39(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38) \
HX_BEGIN_LOCAL_FUNC_S39(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38)
#define HX_BEGIN_LOCAL_FUNC40(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39) \
HX_BEGIN_LOCAL_FUNC_S40(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39)
#define HX_BEGIN_LOCAL_FUNC41(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40) \
HX_BEGIN_LOCAL_FUNC_S41(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40)
#define HX_BEGIN_LOCAL_FUNC42(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41) \
HX_BEGIN_LOCAL_FUNC_S42(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41)
#define HX_BEGIN_LOCAL_FUNC43(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42) \
HX_BEGIN_LOCAL_FUNC_S43(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42)
#define HX_BEGIN_LOCAL_FUNC44(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43) \
HX_BEGIN_LOCAL_FUNC_S44(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43)
#define HX_BEGIN_LOCAL_FUNC45(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44) \
HX_BEGIN_LOCAL_FUNC_S45(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44)
#define HX_BEGIN_LOCAL_FUNC46(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45) \
HX_BEGIN_LOCAL_FUNC_S46(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45)
#define HX_BEGIN_LOCAL_FUNC47(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46) \
HX_BEGIN_LOCAL_FUNC_S47(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46)
#define HX_BEGIN_LOCAL_FUNC48(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47) \
HX_BEGIN_LOCAL_FUNC_S48(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47)
#define HX_BEGIN_LOCAL_FUNC49(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48) \
HX_BEGIN_LOCAL_FUNC_S49(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48)
#define HX_BEGIN_LOCAL_FUNC50(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49) \
HX_BEGIN_LOCAL_FUNC_S50(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49)
#define HX_BEGIN_LOCAL_FUNC51(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50) \
HX_BEGIN_LOCAL_FUNC_S51(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50)
#define HX_BEGIN_LOCAL_FUNC52(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51) \
HX_BEGIN_LOCAL_FUNC_S52(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51)
#define HX_BEGIN_LOCAL_FUNC53(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52) \
HX_BEGIN_LOCAL_FUNC_S53(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52)
#define HX_BEGIN_LOCAL_FUNC54(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53) \
HX_BEGIN_LOCAL_FUNC_S54(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53)
#define HX_BEGIN_LOCAL_FUNC55(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54) \
HX_BEGIN_LOCAL_FUNC_S55(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54)
#define HX_BEGIN_LOCAL_FUNC56(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55) \
HX_BEGIN_LOCAL_FUNC_S56(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55)
#define HX_BEGIN_LOCAL_FUNC57(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56) \
HX_BEGIN_LOCAL_FUNC_S57(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56)
#define HX_BEGIN_LOCAL_FUNC58(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57) \
HX_BEGIN_LOCAL_FUNC_S58(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57)
#define HX_BEGIN_LOCAL_FUNC59(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58) \
HX_BEGIN_LOCAL_FUNC_S59(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58)
#define HX_BEGIN_LOCAL_FUNC60(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59) \
HX_BEGIN_LOCAL_FUNC_S60(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59)
#define HX_BEGIN_LOCAL_FUNC61(name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60) \
HX_BEGIN_LOCAL_FUNC_S61(hx::LocalFunc,name,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7,t8,v8,t9,v9,t10,v10,t11,v11,t12,v12,t13,v13,t14,v14,t15,v15,t16,v16,t17,v17,t18,v18,t19,v19,t20,v20,t21,v21,t22,v22,t23,v23,t24,v24,t25,v25,t26,v26,t27,v27,t28,v28,t29,v29,t30,v30,t31,v31,t32,v32,t33,v33,t34,v34,t35,v35,t36,v36,t37,v37,t38,v38,t39,v39,t40,v40,t41,v41,t42,v42,t43,v43,t44,v44,t45,v45,t46,v46,t47,v47,t48,v48,t49,v49,t50,v50,t51,v51,t52,v52,t53,v53,t54,v54,t55,v55,t56,v56,t57,v57,t58,v58,t59,v59,t60,v60)
#endif

29
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/MacrosJumbo.tpl Normal file
View File

@ -0,0 +1,29 @@
#ifndef HX_MACROS_JUMBO_H
#define HX_MACROS_JUMBO_H
::foreach LOCALS::
#define HX_BEGIN_LOCAL_FUNC_S::ARG::(SUPER,name,::TYPE_ARGS::) \
struct name : public SUPER { \
::TYPE_DECL::; \
void __Mark(hx::MarkContext *__inCtx) { DoMarkThis(__inCtx); ::MARKS:: } \
void __Visit(hx::VisitContext *__inCtx) { DoVisitThis(__inCtx); ::VISITS:: } \
name(::CONSTRUCT_ARGS::) : ::CONSTRUCT_VARS:: {}::end::
#if (HXCPP_API_LEVEL>=330)
#define HX_LOCAL_RUN _hx_run
#else
#define HX_LOCAL_RUN run
#endif
::foreach LOCALS::
#define HX_END_LOCAL_FUNC::ARG::(ret) HX_DYNAMIC_CALL::ARG::(ret, HX_LOCAL_RUN ) };::end::
// For compatibility until next version of haxe is released
::foreach LOCALS::
#define HX_BEGIN_LOCAL_FUNC::ARG::(name,::TYPE_ARGS::) \
HX_BEGIN_LOCAL_FUNC_S::ARG::(hx::LocalFunc,name,::TYPE_ARGS::)::end::
#endif

32
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Memory.h Normal file
View File

@ -0,0 +1,32 @@
#ifdef HX_MEMORY_H_OVERRIDE
// Users can define their own header to use here, but there is no API
// compatibility gaurantee for future changes.
#include HX_MEMORY_H_OVERRIDE
// Todo - special version?
inline void HxFreeGCBlock(void *p) {
HxFree(p);
}
#else
#ifndef HX_MEMORY_H
#define HX_MEMORY_H
#include <stdlib.h>
inline void *HxAlloc(size_t size) {
return malloc(size);
}
inline void HxFree(void *p) {
free(p);
}
void *HxAllocGCBlock(size_t size);
void HxFreeGCBlock(void *p);
#endif
#endif

183
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Native.h Normal file
View File

@ -0,0 +1,183 @@
#ifndef HX_NATIVE_INCLUDED_H
#define HX_NATIVE_INCLUDED_H
/*
*
This file is in the public domain, and can be freely distributed.
*/
#include <stdio.h>
#ifndef HXCPP_H
#define HXCPP_H
typedef double Float;
typedef void Void;
//typedef int Int;
//typedef bool Bool;
#ifndef HXCPP_CLASS_ATTRIBUTES
#define HXCPP_CLASS_ATTRIBUTES
#endif
#endif
#define HX_DECLARE_NATIVE0(klass) \
class klass;
#define HX_DECLARE_NATIVE1(ns1,klass) namespace ns1 { HX_DECLARE_NATIVE0(klass) }
#define HX_DECLARE_NATIVE2(ns2,ns1,klass) namespace ns2 { HX_DECLARE_NATIVE1(ns1,klass) }
#define HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) namespace ns3 { HX_DECLARE_NATIVE2(ns2,ns1,klass) }
#define HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) namespace ns4 { HX_DECLARE_NATIVE3(ns3,ns2,ns1,klass) }
#define HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) namespace ns5 { HX_DECLARE_NATIVE4(ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns6 { HX_DECLARE_NATIVE5(ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns7 { HX_DECLARE_NATIVE6(ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns8 { HX_DECLARE_NATIVE7(ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
#define HX_DECLARE_NATIVE9(ns9,ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) namespace ns9 { HX_DECLARE_NATIVE8(ns8,ns7,ns6,ns5,ns4,ns3,ns2,ns1,klass) }
namespace hx
{
class Object;
class HXCPP_CLASS_ATTRIBUTES NativeInterface
{
public:
virtual hx::Object *__GetRealObject() = 0;
void _hx_addRef();
void _hx_decRef();
};
template<typename T>
class Native
{
public:
T ptr;
Native () : ptr(0) { }
Native (T inPtr) : ptr(inPtr) { }
Native (const Native<T> &inNative) : ptr(inNative.ptr) { }
#ifdef CPP_VARIANT_ONCE_H
Native (const cpp::Variant &inVariant) {
hx::Object *obj = inVariant.asObject();
ptr = obj ? (T)inVariant.valObject->__GetHandle() : 0;
}
#endif
inline Native &operator=(T inPtr) { ptr=inPtr; return *this; }
inline Native &operator=(const Native<T> &inNative) { ptr=inNative.ptr; return *this; }
#ifdef HX_NULL_H
inline Native &operator=(const ::null &) { ptr=0; return *this; }
#endif
inline T operator->() const { return ptr; }
inline operator T() const { return ptr; }
template<typename O>
inline bool operator==(const Native<O> &inOther) const
{ return ptr == inOther.ptr; }
template<typename O>
inline bool operator!=(const Native<O> &inOther) const
{ return ptr != inOther.ptr; }
};
HXCPP_CLASS_ATTRIBUTES const char *Init();
HXCPP_CLASS_ATTRIBUTES void PushTopOfStack(void *);
HXCPP_CLASS_ATTRIBUTES void PopTopOfStack();
HXCPP_CLASS_ATTRIBUTES void GcAddOffsetRoot(void *inRoot, int inOffset);
HXCPP_CLASS_ATTRIBUTES void GcSetOffsetRoot(void *inRoot, int inOffset);
HXCPP_CLASS_ATTRIBUTES void GcRemoveOffsetRoot(void *inRoot);
HXCPP_CLASS_ATTRIBUTES int GcGetThreadAttachedCount();
class HXCPP_CLASS_ATTRIBUTES NativeAttach
{
bool isAttached;
public:
NativeAttach(bool inAttach=true)
{
isAttached = false;
if (inAttach)
attach();
}
~NativeAttach()
{
detach();
}
void attach()
{
if (!isAttached)
{
isAttached = true;
hx::PushTopOfStack(this);
}
}
void detach()
{
if (isAttached)
{
isAttached = false;
hx::PopTopOfStack();
}
}
};
template<typename T>
class Ref
{
public:
T ptr;
Ref() : ptr(0) { }
Ref(const T &inT) : ptr(0) { setPtr(inT); }
template<typename O>
inline Ref(const Native<O> &inNative) : ptr(0) { setPtr(inNative.ptr); }
template<typename O>
inline Ref(const Ref<O> &inRef) : ptr(0) { setPtr(inRef.ptr); }
~Ref() { setPtr(0); }
void setPtr(T inPtr)
{
hx::Object *old = ptr ? ptr->__GetRealObject() : 0;
int oldOffset = old ? (int)(size_t)((char *)inPtr - (char *)old) : 0;
hx::Object *next = inPtr ? inPtr->__GetRealObject() : 0;
int nextOffset = next ? (int)(size_t)((char *)inPtr - (char *)next) : 0;
ptr = inPtr;
if (next)
{
if (!old)
GcAddOffsetRoot(&ptr, nextOffset);
else if (oldOffset!=nextOffset)
GcSetOffsetRoot(&ptr, nextOffset);
}
else if (old)
GcRemoveOffsetRoot(&ptr);
}
inline Ref &operator=(const T &inPtr) { setPtr(inPtr); return *this; }
template<typename O>
inline Ref &operator=(const Native<O> &inNative) { setPtr(inNative.ptr); return *this; }
template<typename O>
inline Ref &operator=(const Ref<O> &inRef) { setPtr(inRef.ptr); return *this; }
template<typename O>
inline bool operator==(const Ref<O> &inOther) const
{ return ptr == inOther.ptr; }
template<typename O>
inline bool operator!=(const Ref<O> &inOther) const
{ return ptr != inOther.ptr; }
T operator->() { return ptr; }
};
#define HX_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return this; }
#define HX_EXTERN_NATIVE_IMPLEMENTATION hx::Object *__GetRealObject() { return 0; }
}
#endif

118
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/NekoFunc.h Normal file
View File

@ -0,0 +1,118 @@
#ifndef HX_NEKO_FUNC_H
#define HX_NEKO_FUNC_H
#define NEKO_VERSION 180
typedef intptr_t int_val;
typedef enum {
VAL_INT = 0xFF,
VAL_NULL = 0,
VAL_FLOAT = 1,
VAL_BOOL = 2,
VAL_STRING = 3,
VAL_OBJECT = 4,
VAL_ARRAY = 5,
VAL_FUNCTION = 6,
VAL_ABSTRACT = 7,
VAL_PRIMITIVE = 6 | 8,
VAL_JITFUN = 6 | 16,
VAL_32_BITS = 0xFFFFFFFF
} neko_val_type;
struct _neko_value {
neko_val_type t;
};
struct _neko_objtable;
struct _neko_buffer;
#ifndef HAVE_NEKO_TYPES
typedef struct _neko_vkind *neko_vkind;
typedef struct _neko_value *neko_value;
typedef struct _neko_buffer *neko_buffer;
#endif
typedef struct _neko_objtable* neko_objtable;
typedef double tfloat;
typedef void (*finalizer)(neko_value v);
#pragma pack(4)
typedef struct {
neko_val_type t;
tfloat f;
} vfloat;
#pragma pack()
typedef struct _vobject {
neko_val_type t;
neko_objtable table;
struct _vobject *proto;
} vobject;
typedef struct {
neko_val_type t;
int nargs;
void *addr;
neko_value env;
void *module;
} vfunction;
typedef struct {
neko_val_type t;
char c;
} vstring;
typedef struct {
neko_val_type t;
neko_value ptr;
} varray;
typedef struct {
neko_val_type t;
neko_vkind kind;
void *data;
} vabstract;
#define neko_val_tag(v) (*(neko_val_type*)(v))
#define neko_val_is_null(v) ((v) == val_null)
#define neko_val_is_int(v) ((((int)(int_val)(v)) & 1) != 0)
#define neko_val_is_number(v) (neko_val_is_int(v) || neko_val_tag(v) == VAL_FLOAT)
#define neko_val_is_float(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_FLOAT)
#define neko_val_is_string(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_STRING)
#define neko_val_is_function(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_FUNCTION)
#define neko_val_is_object(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_OBJECT)
#define neko_val_is_array(v) (!neko_val_is_int(v) && (neko_val_tag(v)&7) == VAL_ARRAY)
#define neko_val_is_abstract(v) (!neko_val_is_int(v) && neko_val_tag(v) == VAL_ABSTRACT)
#define neko_val_is_kind(v,t) (neko_val_is_abstract(v) && neko_val_kind(v) == (t))
#define neko_val_check_kind(v,t) if( !neko_val_is_kind(v,t) ) neko_error();
#define neko_val_check_function(f,n) if( !neko_val_is_function(f) || (neko_val_fun_nargs(f) != (n) && neko_val_fun_nargs(f) != VAR_ARGS) ) neko_error();
#define neko_val_check(v,t) if( !neko_val_is_##t(v) ) neko_error();
#define neko_val_data(v) ((vabstract*)(v))->data
#define neko_val_kind(v) ((vabstract*)(v))->kind
#define neko_val_type(v) (neko_val_is_int(v) ? VAL_INT : (neko_val_tag(v)&7))
#define neko_val_int(v) (((int)(int_val)(v)) >> 1)
#define neko_val_float(v) (CONV_FLOAT ((vfloat*)(v))->f)
#define neko_val_bool(v) ((v) == neko_val_true)
#define neko_val_number(v) (neko_val_is_int(v)?neko_val_int(v):neko_val_float(v))
#define neko_val_hdata(v) ((vhash*)neko_val_data(v))
#define neko_val_string(v) (&((vstring*)(v))->c)
#define neko_val_strlen(v) (neko_val_tag(v) >> 3)
#define neko_val_set_length(v,l) neko_val_tag(v) = (neko_val_tag(v)&7) | ((l) << 3)
#define neko_val_set_size neko_val_set_length
#define neko_val_array_size(v) (neko_val_tag(v) >> 3)
#define neko_val_array_ptr(v) (&((varray*)(v))->ptr)
#define neko_val_fun_nargs(v) ((vfunction*)(v))->nargs
#define neko_alloc_int(v) ((neko_value)(int_val)((((int)(v)) << 1) | 1))
#define neko_alloc_bool(b) ((b)?neko_val_true:neko_val_false)
#define neko_max_array_size ((1 << 29) - 1)
#define neko_max_string_size ((1 << 29) - 1)
#define neko_invalid_comparison 0xFE
#endif // HX_NEKO_FUNC_H

100
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/OS.h Normal file
View File

@ -0,0 +1,100 @@
#ifndef HX_OS_H
#define HX_OS_H
// OS FLAGS
#if defined(_WIN32)
# define NEKO_WINDOWS
#endif
#if defined(__APPLE__) || defined(__MACH__) || defined(macintosh)
# define NEKO_MAC
#endif
#if defined(linux) || defined(__linux__)
# define NEKO_LINUX
#endif
#if defined(__FreeBSD_kernel__)
# define NEKO_GNUKBSD
#endif
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
# define NEKO_BSD
#endif
// COMPILER/PROCESSOR FLAGS
#if defined(__GNUC__)
# define NEKO_GCC
#endif
#if defined(_MSC_VER)
# define NEKO_VCC
#endif
#if defined(__MINGW32__)
# define NEKO_MINGW
#endif
#if defined(__i386__) || defined(_WIN32)
# define NEKO_X86
#endif
#if defined(__ppc__)
# define NEKO_PPC
#endif
#if !defined(_64BITS) && (defined(__LP64__) || defined(_LP64))
#define _64BITS
#endif
#if defined(_64BITS)
# define NEKO_64BITS
#endif
#if defined(NEKO_LINUX) || defined(NEKO_MAC) || defined(NEKO_BSD) || defined(NEKO_GNUKBSD)
# define NEKO_POSIX
#endif
#if defined(NEKO_GCC)
# define NEKO_THREADED
# define NEKO_DIRECT_THREADED
#endif
#include <stddef.h>
#ifndef NEKO_VCC
# include <stdint.h>
#endif
#undef EXPORT
#undef IMPORT
#if defined(NEKO_VCC) || defined(NEKO_MINGW)
# define INLINE __inline
# define EXPORT __declspec( dllexport )
# define IMPORT __declspec( dllimport )
#elif defined (HX_LINUX)
# define INLINE inline
# define EXPORT __attribute__ ((visibility("default")))
# define IMPORT
#else
# define INLINE inline
# define EXPORT __attribute__ ((visibility("default")))
# define IMPORT
#endif
#ifdef NEKO_POSIX
# include <errno.h>
# define POSIX_LABEL(name) name:
# define HANDLE_EINTR(label) if( errno == EINTR ) goto label
# define HANDLE_FINTR(f,label) if( ferror(f) && errno == EINTR ) goto label
#else
# define POSIX_LABEL(name)
# define HANDLE_EINTR(label)
# define HANDLE_FINTR(f,label)
#endif
#endif

222
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/ObjcHelpers.h Normal file
View File

@ -0,0 +1,222 @@
#ifndef HX_OBJC_HELPERS_INCLUDED
#define HX_OBJC_HELPERS_INCLUDED
@interface NSHaxeWrapperClass : NSObject {
@public hx::Object *haxeObject;
}
- (id)init:(hx::Object *) inHaxe;
- (void)dealloc;
@end
NSDictionary<NSString *, id> *_hx_obj_to_nsdictionary(Dynamic d);
id _hx_value_to_objc(Dynamic d);
Dynamic _hx_nsdictionary_to_obj(NSDictionary<NSString *, id> *inDictionary);
Dynamic _hx_objc_to_dynamic(id inValue);
Array<unsigned char> _hx_objc_to_bytes(id value);
namespace hx
{
// 0 args
struct TObjcBlockVoidVoid
{
typedef void (^t)();
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^ {
wrapper->haxeObject->__run();
};
return wrap;
}
};
template<typename Ret>
struct TObjcBlockRetVoid
{
typedef Ret (^t)();
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^() {
return (Ret) wrapper->haxeObject->__run();
};
return wrap;
}
};
// 1 arg
template<typename Arg0>
struct TObjcBlockVoidArgs1
{
typedef void (^t)(Arg0 a);
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0) {
wrapper->haxeObject->__run(a0);
};
return wrap;
}
};
template<typename Ret, typename Arg0>
struct TObjcBlockRetArgs1
{
typedef Ret (^t)(Arg0 a);
inline static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0) {
return (Ret) wrapper->haxeObject->__run(a0);
} ;
}
};
// 2 arg
template<typename Arg0, typename Arg1>
struct TObjcBlockVoidArgs2
{
typedef void (^t)(Arg0 a0, Arg1 a1);
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1) {
wrapper->haxeObject->__run(a0,a1);
};
return wrap;
}
};
template<typename Ret, typename Arg0, typename Arg1>
struct TObjcBlockRetArgs2
{
typedef Ret (^t)(Arg0 a0, Arg1 a1);
inline static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1) {
return (Ret) wrapper->haxeObject->__run(a0,a1);
} ;
}
};
// 3 arg
template<typename Arg0, typename Arg1, typename Arg2>
struct TObjcBlockVoidArgs3
{
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
wrapper->haxeObject->__run(a0,a1,a2);
};
return wrap;
}
};
template<typename Ret, typename Arg0, typename Arg1, typename Arg2>
struct TObjcBlockRetArgs3
{
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2);
inline static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2) {
return (Ret) wrapper->haxeObject->__run(a0,a1,a2);
} ;
}
};
// 4 arg
template<typename Arg0, typename Arg1, typename Arg2, typename Arg3>
struct TObjcBlockVoidArgs4
{
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
wrapper->haxeObject->__run(a0,a1,a2,a3);
};
return wrap;
}
};
template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3>
struct TObjcBlockRetArgs4
{
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3);
inline static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3) {
return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3);
} ;
}
};
// 5 arg
template<typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
struct TObjcBlockVoidArgs5
{
typedef void (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
};
return wrap;
}
};
template<typename Ret, typename Arg0, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
struct TObjcBlockRetArgs5
{
typedef Ret (^t)(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4);
inline static t create(Dynamic func)
{
NSHaxeWrapperClass *wrapper = [[NSHaxeWrapperClass alloc] init:func.mPtr];
t wrap = ^(Arg0 a0, Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) {
return (Ret) wrapper->haxeObject->__run(a0,a1,a2,a3,a4);
} ;
}
};
}
#endif

450
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Object.h Normal file
View File

@ -0,0 +1,450 @@
#ifndef HX_OBJECT_H
#define HX_OBJECT_H
#ifndef HXCPP_H
#error "Please include hxcpp.h, not hx/Object.h"
#endif
#if defined(KORE_LINUX) && __cplusplus < 201103L
#include <math.h>
#endif
// --- Constants -------------------------------------------------------
// These values are returned from the "__GetType" function
enum hxObjectType
{
vtUnknown = -1,
vtInt = 0xff,
vtNull = 0,
vtFloat = 1,
vtBool = 2,
vtString = 3,
vtObject = 4,
vtArray = 5,
vtFunction = 6,
vtEnum,
vtClass,
vtInt64,
vtAbstractBase = 0x100,
};
namespace hx
{
class FieldRef;
class IndexRef;
typedef Array<Dynamic> DynamicArray;
HXCPP_EXTERN_CLASS_ATTRIBUTES null BadCast();
#ifdef HXCPP_SCRIPTABLE
// CPPIA_CALL = fastcall on x86(32), nothing otherwise
#if (HXCPP_API_LEVEL >= 331)
#if (defined(_WIN32) && !defined(_M_X64) && !defined(__x86_64__) && !defined(_ARM_) ) || \
defined(HXCPP_X86) || defined(__i386__) || defined(__i386) || \
(!defined(_WIN32) && !defined(_ARM_) && !defined(__arm__) && !defined(__x86_64__) )
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(EMSCRIPTEN)
#define CPPIA_CALL __attribute__ ((fastcall))
#elif defined(_MSC_VER)
#define CPPIA_CALL __fastcall
#endif
#endif
#endif
#ifndef CPPIA_CALL
#define CPPIA_CALL
#endif
typedef void (CPPIA_CALL *StackExecute)(struct StackContext *ctx);
struct ScriptFunction
{
ScriptFunction(StackExecute inExe=0,const char *inSig=0)
: execute(inExe), signature(inSig) { }
StackExecute execute;
const char *signature;
};
struct ScriptCallable;
#endif
enum NewObjectType
{
NewObjAlloc,
NewObjContainer,
NewObjConst,
};
enum
{
clsIdDynamic = 1,
clsIdClass,
clsIdInt,
clsIdInt64,
clsIdFloat,
clsIdBool,
clsIdString,
clsIdMath,
clsIdEnum,
clsIdClosure,
clsIdVirtualArray,
clsIdArrayIterator,
clsIdArrayBase,
clsIdArrayByte,
clsIdArrayShort,
clsIdArrayInt,
clsIdArrayBool,
clsIdArrayFloat32,
clsIdArrayFloat64,
clsIdArrayString,
clsIdArrayInt64,
clsIdArrayObject,
clsIdAbstract,
clsIdHash,
clsIdWeakRef,
clsIdExternalPrimitive,
clsIdPointer,
clsIdStruct,
clsIdCMember0,
clsIdCMember1,
clsIdCMember2,
clsIdCMember3,
clsIdCMember4,
clsIdCMember5,
clsIdCMemberVar,
clsIdCStatic0,
clsIdCStatic1,
clsIdCStatic2,
clsIdCStatic3,
clsIdCStatic4,
clsIdCStatic5,
clsIdCStatic6,
clsIdCStaticVar,
clsIdMutex,
clsIdSemaphore,
clsIdCondition,
clsIdLock,
clsIdDeque,
clsIdThreadInfo,
clsIdPcreData,
clsIdFio,
clsIdProcess,
clsIdSocket,
clsIdRandom,
clsIdPollData,
clsIdSqlite,
clsIdMysql,
clsIdMysqlResult,
clsIdSsl,
clsIdSslCert,
clsIdSslConf,
clsIdSslKey,
clsIdZLib,
};
// --- hx::Object ------------------------------------------------------------
//
// Base for all hxcpp objects.
// This contains the virtual functions required by the core to provide
// a generic interface to the specific classes.
//
// Hxcpp classes inherit from this.
//
class HXCPP_EXTERN_CLASS_ATTRIBUTES Object
{
public:
enum { _hx_ClassId = hx::clsIdDynamic };
inline void *operator new( size_t inSize, bool inContainer=true, const char *inName=0 )
{
#ifdef HX_USE_INLINE_IMMIX_OPERATOR_NEW
ImmixAllocator *alloc = HX_CTX_GET;
#ifdef HXCPP_DEBUG
if (!alloc)
BadImmixAlloc();
#endif
return ImmixAllocator::alloc(alloc, inSize, inContainer, inName);
#else // Not HX_USE_INLINE_IMMIX_OPERATOR_NEW ...
void *result = hx::InternalNew(inSize,inContainer);
#ifdef HXCPP_TELEMETRY
__hxt_gc_new(result, inSize, inName);
#endif
return result;
#endif
}
inline void *operator new( size_t inSize, hx::NewObjectType inType, const char *inName=0 )
{
if (inType==NewObjConst)
return InternalCreateConstBuffer(0,(int)inSize);
return operator new(inSize, inType==NewObjContainer, inName);
}
void operator delete( void *, bool) { }
void operator delete( void *, bool, const char * ) { }
void operator delete( void *, int ) { }
void operator delete( void *, hx::NewObjectType) { }
void operator delete( void *, hx::NewObjectType, const char * ) { }
#if (HXCPP_API_LEVEL>=332)
virtual bool _hx_isInstanceOf(int inClassId);
#endif
//virtual void *__root();
virtual void __Mark(hx::MarkContext *__inCtx) { }
#ifdef HXCPP_VISIT_ALLOCS
virtual void __Visit(hx::VisitContext *__inCtx) { }
#endif
// helpers...
inline bool __IsArray() const { return __GetType()==vtArray; }
virtual int __GetType() const { return vtClass; }
virtual void *__GetHandle() const { return 0; }
virtual hx::FieldRef __FieldRef(const String &inString);
virtual String __ToString() const;
virtual int __ToInt() const { return 0; }
#if defined(KORE_LINUX) && __cplusplus < 201103L
virtual double __ToDouble() const { return NAN; }
#else
virtual double __ToDouble() const { return std::numeric_limits<double>::quiet_NaN(); }
#endif
virtual cpp::Int64 __ToInt64() const { return (cpp::Int64)(0); }
virtual const char * __CStr() const;
virtual String toString();
virtual bool __HasField(const String &inString);
virtual hx::Val __Field(const String &inString, hx::PropertyAccess inCallProp);
#if (HXCPP_API_LEVEL <= 330)
virtual bool __Is(hx::Object *inClass) const { return true; }
virtual hx::Object *__GetRealObject() { return this; }
bool __Is(Dynamic inClass ) const;
#endif
#if (HXCPP_API_LEVEL >= 330)
// Non-virtual
Dynamic __IField(int inFieldID);
double __INumField(int inFieldID);
virtual void *_hx_getInterface(int inId);
#else
virtual hx::Object *__ToInterface(const hx::type_info &inInterface) { return 0; }
virtual Dynamic __IField(int inFieldID);
virtual double __INumField(int inFieldID);
// These have been moved to EnumBase
virtual DynamicArray __EnumParams();
virtual String __Tag() const;
virtual int __Index() const;
virtual void __SetSize(int inLen) { }
#endif
virtual hx::Val __SetField(const String &inField,const hx::Val &inValue, hx::PropertyAccess inCallProp);
virtual void __SetThis(Dynamic inThis);
virtual Dynamic __Run(const Array<Dynamic> &inArgs);
virtual Dynamic *__GetFieldMap();
virtual void __GetFields(Array<String> &outFields);
virtual hx::Class __GetClass() const;
virtual int __Compare(const hx::Object *inRHS) const;
virtual int __length() const { return 0; }
virtual Dynamic __GetItem(int inIndex) const;
virtual Dynamic __SetItem(int inIndex,Dynamic inValue);
typedef const Dynamic &D;
virtual Dynamic __run();
virtual Dynamic __run(D a);
virtual Dynamic __run(D a,D b);
virtual Dynamic __run(D a,D b,D c);
virtual Dynamic __run(D a,D b,D c,D d);
virtual Dynamic __run(D a,D b,D c,D d,D e);
virtual int __ArgCount() const { return -1; }
#ifdef HXCPP_SCRIPTABLE
virtual void **__GetScriptVTable() { return 0; }
virtual hx::ScriptCallable *__GetScriptCallable() { return 0; }
static hx::ScriptFunction __script_construct;
#endif
#if (HXCPP_API_LEVEL>=331)
inline bool __compare( hx::Object *inRHS ) { return this!=inRHS; }
#else
inline bool __compare( hx::Object *inRHS )
{ return __GetRealObject()!=inRHS->__GetRealObject(); }
#endif
static hx::Class &__SGetClass();
static void __boot();
};
// --- hx::ObjectPtr ---------------------------------------------------------------
//
// This class simply provides syntax so that pointers can be written as objects,
// and overloaded operators can be used
template<typename OBJ_>
class ObjectPtr
{
protected:
inline bool SetPtr(OBJ_ *inPtr)
{
mPtr = inPtr;
return true;
}
inline bool SetPtr(...) { return false; }
inline void CastPtr(hx::Object *inPtr,bool inThrowOnInvalid)
{
if (inPtr)
{
#if (HXCPP_API_LEVEL>=332)
mPtr = inPtr->_hx_isInstanceOf(OBJ_::_hx_ClassId) ? reinterpret_cast<OBJ_ *>(inPtr) : 0;
#elif (HXCPP_API_LEVEL>=331)
mPtr = dynamic_cast<OBJ_ *>(inPtr);
#else
mPtr = dynamic_cast<OBJ_ *>(inPtr->__GetRealObject());
#if (HXCPP_API_LEVEL < 330)
if (!mPtr)
mPtr = (Ptr)inPtr->__ToInterface(typeid(Obj));
#endif
#endif
if (inThrowOnInvalid && !mPtr)
::hx::BadCast();
}
else
mPtr = 0;
}
public:
typedef OBJ_ Obj;
typedef OBJ_ *Ptr;
inline ObjectPtr() : mPtr(0) { }
inline ObjectPtr(OBJ_ *inObj) : mPtr(inObj) { }
inline ObjectPtr(const null &inNull) : mPtr(0) { }
inline ObjectPtr(const ObjectPtr<OBJ_> &inOther) : mPtr( inOther.mPtr ) { }
template<typename T>
inline ObjectPtr(const hx::Native<T> &inNative) : mPtr( dynamic_cast<T>(inNative.ptr) ) { }
template<typename SOURCE_>
inline ObjectPtr(const ObjectPtr<SOURCE_> &inObjectPtr)
{
if (!SetPtr(inObjectPtr.mPtr))
CastPtr(inObjectPtr.mPtr,false);
}
inline ObjectPtr(const ::cpp::Variant &inVariant)
{
hx::Object *object = inVariant.asObject();
if (!SetPtr(object))
CastPtr(object,false);
}
template<typename SOURCE_>
inline ObjectPtr(const SOURCE_ *inPtr,bool inCheckCast=true)
{
if (!SetPtr(const_cast<SOURCE_ *>(inPtr)))
CastPtr(const_cast<SOURCE_ *>(inPtr),inCheckCast);
}
inline ObjectPtr &operator=(const null &inNull) { mPtr = 0; return *this; }
inline ObjectPtr &operator=(Ptr inRHS) { mPtr = inRHS; return *this; }
inline ObjectPtr &operator=(const ObjectPtr &inRHS) { mPtr = inRHS.mPtr; return *this; }
template<typename InterfaceImpl>
inline ObjectPtr &operator=(InterfaceImpl *inRHS)
{
mPtr = inRHS->operator Ptr();
return *this;
}
inline OBJ_ *GetPtr() const { return mPtr; }
inline OBJ_ *operator->()
{
#ifdef HXCPP_CHECK_POINTER
if (!mPtr) NullReference("Object", true);
// The handler might have fixed up the null value
if (!mPtr) NullReference("Object", false);
#ifdef HXCPP_GC_CHECK_POINTER
GCCheckPointer(mPtr);
#endif
#endif
return mPtr;
}
inline const OBJ_ *operator->() const
{
#ifdef HXCPP_CHECK_POINTER
if (!mPtr) NullReference("Object", true);
// The handler might have fixed up the null value
if (!mPtr) NullReference("Object", false);
#ifdef HXCPP_GC_CHECK_POINTER
GCCheckPointer(mPtr);
#endif
#endif
return mPtr;
}
template<typename T>
inline bool operator==(const T &inTRHS) const
{
ObjectPtr inRHS(inTRHS.mPtr,false);
if (mPtr==inRHS.mPtr) return true;
if (!mPtr || !inRHS.mPtr) return false;
return !mPtr->__compare(inRHS.mPtr);
}
inline bool operator==(const cpp::Variant &inRHS) const;
inline bool operator!=(const cpp::Variant &inRHS) const;
template<typename T>
inline bool operator!=(const T &inTRHS) const
{
ObjectPtr inRHS(inTRHS.mPtr,false);
if (mPtr==inRHS.mPtr) return false;
if (!mPtr || !inRHS.mPtr) return true;
return mPtr->__compare(inRHS.mPtr);
}
template<typename T>
operator hx::Native<T> () { return hx::Native<T>( mPtr ); }
inline bool operator==(const null &inRHS) const { return mPtr==0; }
inline bool operator!=(const null &inRHS) const { return mPtr!=0; }
//inline bool operator==(const Dynamic &inRHS) const { return inRHS==*this; }
//inline bool operator!=(const Dynamic &inRHS) const { return inRHS!=*this; }
// This is defined in the "FieldRef" class...
inline class hx::FieldRef FieldRef(const String &inString);
inline class hx::IndexRef IndexRef(int inString);
inline static hx::Class &__SGetClass() { return OBJ_::__SGetClass(); }
OBJ_ *mPtr;
};
} // end namespace hx
#endif

448
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Operators.h Normal file
View File

@ -0,0 +1,448 @@
#ifndef HX_OPERATORS_H
#define HX_OPERATORS_H
template<typename T> bool null::operator == (const hx::ObjectPtr<T> &O) const { return !O.mPtr; }
template<typename T> inline bool null::operator != (const hx::ObjectPtr<T> &O) const { return O.mPtr; }
template<typename T> inline bool null::operator == (const Array<T> &O) const { return !O.mPtr; }
template<typename T> inline bool null::operator != (const Array<T> &O) const { return O.mPtr; }
inline bool null::operator == (const hx::FieldRef &O) const { return !O.HasPointer(); }
inline bool null::operator != (const hx::FieldRef &O) const { return O.HasPointer(); }
inline bool null::operator == (const hx::IndexRef &O) const { return !O.HasPointer(); }
inline bool null::operator != (const hx::IndexRef &O) const { return O.HasPointer(); }
inline bool null::operator == (const Dynamic &O) const { return !O.mPtr; }
inline bool null::operator != (const Dynamic &O) const { return O.mPtr; }
inline bool null::operator == (const String &O) const { return !O.raw_ptr(); }
inline bool null::operator != (const String &O) const { return O.raw_ptr(); }
namespace hx {
template<typename T> Null<T>::operator Dynamic() { if (isNull) return Dynamic(); return value; }
}
HX_COMPARE_NULL_MOST_OPS(String)
HX_COMPARE_NULL_MOST_OPS(Dynamic)
HX_COMPARE_NULL_MOST_OPS(hx::FieldRef)
HX_COMPARE_NULL_MOST_OPS(hx::IndexRef)
//HX_NULL_DEFINE_COMPARE_MOST_OPS(String)
//HX_NULL_DEFINE_COMPARE_MOST_OPS(Dynamic)
//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::FieldRef)
//HX_NULL_DEFINE_COMPARE_MOST_OPS(hx::IndexRef)
// Operators for mixing various types ....
inline String operator+(const cpp::UInt64 &i,const String &s) { return String(i) + s; }
inline String operator+(const cpp::Int64 &i,const String &s) { return String(i) + s; }
inline String operator+(const int &i,const String &s) { return String(i) + s; }
inline String operator+(const unsigned int &i,const String &s) { return String(i) + s; }
inline String operator+(const double &d,const String &s) { return String(d) + s; }
inline String operator+(const float &d,const String &s) { return String(d) + s; }
inline String operator+(const bool &b,const String &s) { return String(b) + s; }
inline String operator+(const unsigned char c,const String &s) { return String(c) + s; }
inline String operator+(const signed char c,const String &s) { return String(c) + s; }
inline String operator+(const unsigned short c,const String &s) { return String(c) + s; }
inline String operator+(const signed short c,const String &s) { return String(c) + s; }
inline String operator+(const null &n,const String &s) { return String(n) + s; }
inline String operator+(const cpp::CppInt32__ &i,const String &s) { return String(i) + s; }
template<typename T_>
inline String operator+(const hx::ObjectPtr<T_> &inLHS,const String &s)
{ return (inLHS.mPtr ? const_cast<hx::ObjectPtr<T_> & >(inLHS)->toString() : HX_CSTRING("null") ) + s; }
/*
template<typename LHS_>
inline Dynamic operator+(LHS_ inLHS, const hx::FieldRef &inField)
{ return inLHS + inField.operator Dynamic(); }
template<typename LHS_>
inline Dynamic operator+(LHS_ inLHS,const hx::IndexRef &inIndexRef)
{ return inLHS + inIndexRef.operator Dynamic(); }
*/
// += -= *= /= %= &= |= ^= <<= >>= >>>=
namespace hx
{
template<typename T> inline double ToDouble(T inT) { return 0; }
template<typename T> inline double ToDouble(hx::ObjectPtr<T> inObj)
{
return inObj.mPtr ? inObj.mPtr->__ToDouble() : 0.0;
}
template<> inline double ToDouble(String inValue) { return __hxcpp_parse_float(inValue); }
template<> inline double ToDouble(double inValue) { return inValue; }
template<> inline double ToDouble(int inValue) { return inValue; }
template<> inline double ToDouble(bool inValue) { return inValue; }
template<> inline double ToDouble(float inValue) { return inValue; }
template<> inline double ToDouble(cpp::UInt64 inValue) { return inValue; }
template<> inline double ToDouble(cpp::Int64 inValue) { return inValue; }
template<> inline double ToDouble(null inValue) { return 0; }
inline int UShr(int inData,int inShift)
{
return ((unsigned int)inData) >> inShift;
}
HXCPP_EXTERN_CLASS_ATTRIBUTES double DoubleMod(double inLHS,double inRHS);
template<typename TL,typename TR>
double Mod(TL inLHS,TR inRHS) { return hx::DoubleMod(inLHS,inRHS); }
double DivByZero(double d);
#if !defined(_MSC_VER) || _MSC_VER > 1399
inline int Mod(int inLHS,int inRHS)
{
if (!inRHS)
hx::Throw(HX_CSTRING("Mod by 0 Error."));
return inLHS % inRHS;
}
#endif
template<typename L, typename R>
inline L& AddEq(L &inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
template<typename L, typename R>
inline L& MultEq(L &inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
template<typename L, typename R>
inline L& DivEq(L &inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
template<typename L, typename R>
inline L& SubEq(L &inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
template<typename L, typename R>
inline L& AndEq(L &inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
template<typename L, typename R>
inline L& OrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
template<typename L, typename R>
inline L& XorEq(L &inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
template<typename L, typename R>
inline L& ShlEq(L &inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
template<typename L, typename R>
inline L& ShrEq(L &inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
template<typename L, typename R>
inline L& UShrEq(L &inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
template<typename L, typename R>
inline L& ModEq(L &inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
#if defined(__GNUC__) || defined(__SNC__)
template<typename R>
inline hx::FieldRef AddEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef MultEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS * inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef DivEq(hx::FieldRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef SubEq(hx::FieldRef inLHS, R inRHS) { inLHS = inLHS - inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef AndEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef OrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef XorEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef ShlEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef ShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
template<typename R>
inline hx::FieldRef UShrEq(hx::FieldRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
template<typename R>
inline hx::FieldRef ModEq(hx::FieldRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
template<typename R>
inline hx::IndexRef AddEq(hx::IndexRef inLHS, R inRHS) { inLHS = inLHS + inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef MultEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS * (double)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef DivEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS / (double)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef SubEq(hx::IndexRef inLHS, R inRHS) { inLHS = (double)inLHS - (double)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef AndEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS & (int)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef OrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS | (int)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef XorEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS ^ (int)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef ShlEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS << (int)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef ShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = (int)inLHS >> (int)inRHS; return inLHS; }
template<typename R>
inline hx::IndexRef UShrEq(hx::IndexRef inLHS, R inRHS) { inLHS = hx::UShr(inLHS,inRHS); return inLHS; }
template<typename R>
inline hx::IndexRef ModEq(hx::IndexRef inLHS, R inRHS) { inLHS = DoubleMod(inLHS,inRHS); return inLHS; }
#endif // __GNUC__ || __SNC__
template<typename R,typename T>
inline hx::__TArrayImplRef<T> AddEq(hx::__TArrayImplRef<T> ref, R inRHS)
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) + inRHS); return ref;}
template<typename R,typename T>
inline hx::__TArrayImplRef<T> MultEq(hx::__TArrayImplRef<T> ref, R inRHS)
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) * inRHS); return ref;}
template<typename R,typename T>
inline hx::__TArrayImplRef<T> DivEq(hx::__TArrayImplRef<T> ref, R inRHS)
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) / inRHS); return ref;}
template<typename R,typename T>
inline hx::__TArrayImplRef<T> SubEq(hx::__TArrayImplRef<T> ref, R inRHS)
{ ref.mObject->__set(ref.mIndex, ref.mObject->__get(ref.mIndex) - inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> AndEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) & inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> OrEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) | inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> XorEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) ^ inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> ShlEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) << inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> ShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, (int)ref.mObject->__get(ref.mIndex) >> inRHS); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, int inRHS)
{ ref.mObject->__set(ref.mIndex, hx::UShr(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
template<typename T>
inline hx::__TArrayImplRef<T> UShrEq(hx::__TArrayImplRef<T> ref, double inRHS)
{ ref.mObject->__set(ref.mIndex, DoubleMod(ref.mObject->__get(ref.mIndex),inRHS)); return ref;}
template<typename T> inline T TCastObject(hx::Object *inObj) { return hx::BadCast(); }
template<> inline bool TCastObject<bool>(hx::Object *inObj)
{
if (!inObj) return false;
if (inObj->__GetType()!=::vtBool) return hx::BadCast();
return inObj?inObj->__ToInt():0;
}
template<> inline int TCastObject<int>(hx::Object *inObj)
{
if (!inObj) return 0;
if (!(inObj->__GetType()==::vtInt ||
((inObj->__GetType()==::vtFloat || inObj->__GetType()==::vtInt64) && inObj->__ToDouble()==inObj->__ToInt()) ) ) return hx::BadCast();
return inObj->__ToInt();
}
template<> inline double TCastObject<double>(hx::Object *inObj)
{
if (!inObj) return 0.0;
if ((inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
return hx::BadCast();
return inObj->__ToDouble();
}
template<> inline float TCastObject<float>(hx::Object *inObj)
{
if (!inObj || (inObj->__GetType()!=::vtFloat && inObj->__GetType()!=::vtInt64 && inObj->__GetType()!=::vtInt))
return hx::BadCast();
return inObj->__ToDouble();
}
template<> inline String TCastObject<String>(hx::Object *inObj)
{
if (!inObj) return String();
if (inObj->__GetType()!=::vtString)
return hx::BadCast();
return inObj->__ToString();
}
template<> inline null TCastObject<null>(hx::Object *inObj) { return null(); }
// Cast to scalar
template<typename T> struct TCast
{
template<typename VAL> static inline T cast(VAL inVal ) {
T result = TCastObject<T>(Dynamic(inVal).GetPtr());
//null string from null is ok...
//if (result==null()) hx::BadCast();
return result;
}
template<typename INOBJ>
static inline T cast(ObjectPtr<INOBJ> inObj )
{
T result = TCastObject<T>(inObj.GetPtr());
if (result==null()) hx::BadCast();
return result;
}
template<typename INOBJ>
static inline T cast(Array<INOBJ> inObj ) { return hx::BadCast(); }
};
// Cast to object
template<typename T> struct TCast< ObjectPtr<T> >
{
template<typename VAL> static inline ObjectPtr<T> cast(VAL inVal ) {
ObjectPtr<T> result = Dynamic(inVal);
if (result==null() && inVal!=null()) BadCast();
return result;
}
template<typename INOBJ>
static inline ObjectPtr<T> cast(ObjectPtr<INOBJ> inObj )
{
ObjectPtr<T> result = ObjectPtr<T>(inObj);
if (result==null() && inObj!=null()) hx::BadCast();
return result;
}
};
#if (HXCPP_API_LEVEL >= 330)
template< > struct TCast< cpp::VirtualArray >
{
template<typename VAL> static inline cpp::VirtualArray cast(VAL inVal ) {
return cpp::VirtualArray(inVal);
}
};
#endif
// Cast to struct
template<typename T,typename H> struct TCast< cpp::Struct<T,H> >
{
static inline cpp::Struct<T,H> cast( const cpp::Struct<T,H> &inObj ) { return inObj; }
};
inline Array<Dynamic> TCastToArray(Dynamic inVal)
{
Dynamic result = inVal;
if (result==null() && inVal!=null()) hx::BadCast();
return inVal;
}
template<typename PTRTYPE> struct DynamicConvertType { enum { Convert = aciNotArray }; };
// Always convert ...
template<> struct DynamicConvertType< hx::Interface * > { enum { Convert = aciAlwaysConvert }; };
template<> struct DynamicConvertType< Array_obj<Dynamic> * > { enum { Convert = aciObjectArray }; };
template<> struct DynamicConvertType< Array_obj< ::String> * > { enum { Convert = aciStringArray }; };
template<typename T> struct DynamicConvertType< Array_obj<T> * > { enum { Convert = sizeof(T) }; };
#if (HXCPP_API_LEVEL >= 330)
template<> struct DynamicConvertType< cpp::VirtualArray_obj * > { enum { Convert = aciVirtualArray }; };
#endif
}
template<typename RESULT>
inline RESULT Dynamic::StaticCast() const
{
typedef typename RESULT::Ptr type;
const int convertId = (int)hx::DynamicConvertType<type>::Convert;
if (convertId!=hx::aciNotArray && mPtr && convertId!=((hx::ArrayCommon *)mPtr)->getArrayConvertId())
{
// Constructing the result from the Dynamic value will check for a conversion
// using something like dynamic_cast
return *this;
}
else
{
// Simple reinterpret_cast
return (typename RESULT::Ptr)mPtr;
}
}
namespace hx
{
inline bool IsInterfacePtr(...) { return false; }
inline bool IsInterfacePtr(const hx::Interface *) { return true; }
}
template<typename VALUE>
inline void __hxcpp_unsafe_set(hx::ObjectPtr<VALUE> &outForced, const Dynamic &inD)
{
if (hx::IsInterfacePtr(outForced.mPtr))
{
hx::Throw(HX_CSTRING("unsafe set of interfaces not supported yet."));
outForced.mPtr = (VALUE *)(inD.mPtr);
}
else
{
#if (HXCPP_API_LEVEL >= 331)
outForced.mPtr = (VALUE *)(inD.mPtr);
#else
outForced.mPtr = (VALUE *)(inD.mPtr ? inD.mPtr->__GetRealObject() : 0);
#endif
}
}
namespace hx
{
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringValueIterator : public cpp::StringIterator<int>
{
public:
StringValueIterator(const String &inValue) : StringIterator(inValue) { }
int next() { return value.cca(pos++); }
};
class HXCPP_EXTERN_CLASS_ATTRIBUTES StringKeyValueIterator : public cpp::StringIterator<Dynamic>
{
public:
StringKeyValueIterator(const String &inValue) : StringIterator(inValue) { }
Dynamic next() {
int p = pos;
return
hx::AnonStruct2_obj< int,int >::Create(HX_("key",9f,89,51,00),p,
HX_("value",71,7f,b8,31), value.cca(pos++) );
}
};
}
Dynamic String::iterator()
{
return new hx::StringValueIterator(*this);
}
Dynamic String::keyValueIterator()
{
return new hx::StringKeyValueIterator(*this);
}
namespace hx
{
template<typename FROM, typename TO> Dynamic hx::ArrayKeyValueIterator<FROM, TO>::next()
{
int p = mIdx++;
return
hx::AnonStruct2_obj< int,TO >::Create(HX_("key",9f,89,51,00),p,
HX_("value",71,7f,b8,31), toTo(mArray->__get(p)) );
}
}
#endif

204
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/QuickVec.h Normal file
View File

@ -0,0 +1,204 @@
#ifndef HX_QUICKVEC_INCLUDED
#define HX_QUICKVEC_INCLUDED
#include <stdlib.h>
#include <algorithm>
namespace hx
{
template<typename T>
struct QuickVec
{
int mAlloc;
int mSize;
T *mPtr;
QuickVec() : mPtr(0), mAlloc(0), mSize(0) { }
~QuickVec()
{
if (mPtr)
free(mPtr);
}
inline void push(const T &inT)
{
if (mSize+1>mAlloc)
{
mAlloc = 10 + (mSize*3/2);
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
}
mPtr[mSize]=inT;
mSize++;
}
void swap(QuickVec<T> &inOther)
{
std::swap(mAlloc, inOther.mAlloc);
std::swap(mSize, inOther.mSize);
std::swap(mPtr, inOther.mPtr);
}
T *setSize(int inSize)
{
if (inSize>mAlloc)
{
mAlloc = inSize;
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
}
mSize = inSize;
return mPtr;
}
// Can push this many without realloc
bool hasExtraCapacity(int inN)
{
return mSize+inN<=mAlloc;
}
bool safeReserveExtra(int inN)
{
int want = mSize + inN;
if (want>mAlloc)
{
int wantAlloc = 10 + (mSize*3/2);
if (wantAlloc<want)
wantAlloc = want;
T *newBuffer = (T *)malloc( sizeof(T)*wantAlloc );
if (!newBuffer)
return false;
mAlloc = wantAlloc;
if (mPtr)
{
memcpy(newBuffer, mPtr, mSize*sizeof(T));
free(mPtr);
}
mPtr = newBuffer;
}
return true;
}
inline void pop_back() { --mSize; }
inline T &back() { return mPtr[mSize-1]; }
inline T pop()
{
return mPtr[--mSize];
}
inline void qerase(int inPos)
{
--mSize;
mPtr[inPos] = mPtr[mSize];
}
inline void erase(int inPos)
{
--mSize;
if (mSize>inPos)
memmove(mPtr+inPos, mPtr+inPos+1, (mSize-inPos)*sizeof(T));
}
void zero() { memset(mPtr,0,mSize*sizeof(T) ); }
inline bool qerase_val(T inVal)
{
for(int i=0;i<mSize;i++)
if (mPtr[i]==inVal)
{
--mSize;
mPtr[i] = mPtr[mSize];
return true;
}
return false;
}
inline bool some_left() { return mSize; }
inline bool empty() const { return !mSize; }
inline void clear() { mSize = 0; }
inline int next()
{
if (mSize+1>=mAlloc)
{
mAlloc = 10 + (mSize*3/2);
mPtr = (T *)realloc(mPtr,sizeof(T)*mAlloc);
}
return mSize++;
}
inline int size() const { return mSize; }
inline T &operator[](int inIndex) { return mPtr[inIndex]; }
inline const T &operator[](int inIndex) const { return mPtr[inIndex]; }
private:
QuickVec(const QuickVec<T> &);
void operator =(const QuickVec<T> &);
};
template<typename T>
class QuickDeque
{
struct Slab
{
T mElems[1024];
};
QuickVec<Slab *> mSpare;
QuickVec<Slab *> mActive;
int mHeadPos;
int mTailPos;
Slab *mHead;
Slab *mTail;
public:
QuickDeque()
{
mHead = mTail = 0;
mHeadPos = 1024;
mTailPos = 1024;
}
~QuickDeque()
{
for(int i=0;i<mSpare.size();i++)
delete mSpare[i];
for(int i=0;i<mActive.size();i++)
delete mActive[i];
delete mHead;
if (mTail!=mHead)
delete mTail;
}
inline void push(T inObj)
{
if (mHeadPos<1024)
{
mHead->mElems[mHeadPos++] = inObj;
return;
}
if (mHead != mTail)
mActive.push(mHead);
mHead = mSpare.empty() ? new Slab : mSpare.pop();
mHead->mElems[0] = inObj;
mHeadPos = 1;
}
inline bool some_left() { return mHead!=mTail || mHeadPos!=mTailPos; }
inline T pop()
{
if (mTailPos<1024)
return mTail->mElems[mTailPos++];
if (mTail)
mSpare.push(mTail);
if (mActive.empty())
{
mTail = mHead;
}
else
{
mTail = mActive[0];
mActive.erase(0);
}
mTailPos = 1;
return mTail->mElems[0];
}
private:
QuickDeque(const QuickDeque<T> &);
void operator=(const QuickDeque<T> &);
};
} // end namespace hx
#endif

289
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Scriptable.h Normal file
View File

@ -0,0 +1,289 @@
#ifndef INCLUDED_HX_SCRIPTABLE
#define INCLUDED_HX_SCRIPTABLE
#include <typeinfo>
#ifdef __clang__
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#endif
namespace hx
{
extern bool gEnableJit;
inline void EnableJit(bool inEnable) { gEnableJit = inEnable; }
#define HXCPP_CPPIA_SUPER_ARG(x) , (x)
struct ScriptNamedFunction : public ScriptFunction
{
ScriptNamedFunction(const ScriptFunction &s) : ScriptFunction(s), name(0), isStatic(false), superExecute(0) { }
ScriptNamedFunction(const char *inName=0,StackExecute inExe=0,const char *inSig=0, bool inIsStatic=false, StackExecute superExecute=0)
: ScriptFunction(inExe, inSig), name(inName), isStatic(inIsStatic), superExecute(superExecute) { }
const char *name;
bool isStatic;
StackExecute superExecute;
};
inline void SetFloatAligned(void *inPtr, const Float &inValue)
{
#ifdef HXCPP_ALIGN_FLOAT
int *dest = (int *)inPtr;
const int *src = (const int *)&inValue;
dest[1] = src[1];
#else
*(Float *)inPtr = inValue;
#endif
}
inline Float GetFloatAligned(const void *inPtr)
{
#ifdef HXCPP_ALIGN_FLOAT
Float result;
int *dest = (int *)&result;
const int *src = (const int *)inPtr;
dest[0] = src[0];
dest[1] = src[1];
return result;
#else
return *(Float *)inPtr;
#endif
}
inline void StackContext::pushFloat(Float f)
{
SetFloatAligned(pointer, f);
pointer += sizeof(Float);
}
inline void StackContext::pushString(const String &s)
{
*(String *)pointer = s;
pointer += sizeof(String);
}
inline void StackContext::pushObject(Dynamic d)
{
*(hx::Object **)pointer = d.mPtr;
pointer += sizeof(hx::Object *);
}
inline void StackContext::returnFloat(Float f)
{
SetFloatAligned(frame, f);
}
inline void StackContext::returnString(const String &s)
{
*(String *)frame = s;
}
inline void StackContext::returnObject(Dynamic d)
{
*(hx::Object **)frame = d.mPtr;
}
inline hx::Object *StackContext::getThis(bool inCheckPtr)
{
#ifdef HXCPP_CHECK_POINTER
if (inCheckPtr)
{
if (!*(hx::Object **)frame) NullReference("This", false);
#ifdef HXCPP_GC_CHECK_POINTER
GCCheckPointer(*(hx::Object **)frame);
#endif
}
#endif
return *(hx::Object **)frame;
}
inline Float StackContext::getFloat(int inPos)
{
return GetFloatAligned(frame+inPos);
}
inline String StackContext::getString(int inPos)
{
return *(String *)(frame+inPos);
}
inline Dynamic StackContext::getObject(int inPos)
{
return *(hx::Object **)(frame+inPos);
}
enum SignatureChar
{
sigVoid = 'v',
sigBool = 'b',
sigInt = 'i',
sigFloat = 'f',
sigString = 's',
sigObject = 'o',
};
struct AutoStack
{
CppiaCtx *ctx;
unsigned char *pointer;
unsigned char *frame;
AutoStack(CppiaCtx *inCtx) : ctx(inCtx)
{
frame = ctx->frame;
pointer = ctx->pointer;
ctx->frame = pointer;
}
AutoStack(CppiaCtx *inCtx,unsigned char *inPointer) : ctx(inCtx)
{
frame = ctx->frame;
pointer = inPointer;
ctx->frame = pointer;
}
~AutoStack()
{
ctx->pointer = pointer;
ctx->frame = frame;
}
};
typedef hx::Object * (*ScriptableClassFactory)(void **inVTable,int inDataSize);
typedef hx::Object * (*ScriptableInterfaceFactory)(void **inVTable,::hx::Object *);
void ScriptableRegisterClass( String inName, int inBaseSize, ScriptNamedFunction *inFunctions, ScriptableClassFactory inFactory, ScriptFunction inConstruct);
#if (HXCPP_API_LEVEL >= 330)
void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions, void *inInterfacePointers);
void ScriptableRegisterNameSlots(const char *inNames[], int inLength);
#else
void ScriptableRegisterInterface( String inName, ScriptNamedFunction *inFunctions,const hx::type_info *inType, ScriptableInterfaceFactory inFactory);
#endif
::String ScriptableToString(void *);
hx::Class ScriptableGetClass(void *);
int ScriptableGetType(void *);
void ScriptableMark(void *, hx::Object *, HX_MARK_PARAMS);
void ScriptableVisit(void *, hx::Object *, HX_VISIT_PARAMS);
bool ScriptableField(hx::Object *, const ::String &,hx::PropertyAccess inCallProp,Dynamic &outResult);
bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Float &outResult);
bool ScriptableField(hx::Object *, int inName,hx::PropertyAccess inCallProp,Dynamic &outResult);
void ScriptableGetFields(hx::Object *inObject, Array< ::String> &outFields);
bool ScriptableSetField(hx::Object *, const ::String &, Dynamic inValue,hx::PropertyAccess inCallProp, Dynamic &outValue);
class CppiaLoadedModule_obj : public ::hx::Object
{
public:
virtual void run() = 0;
virtual void boot() = 0;
virtual ::hx::Class resolveClass( ::String inName) = 0;
};
typedef ::hx::ObjectPtr<CppiaLoadedModule_obj> CppiaLoadedModule;
} // End namespace hx
void __scriptable_load_neko(String inName);
void __scriptable_load_cppia(String inCode);
::hx::CppiaLoadedModule __scriptable_cppia_from_string(String inCode);
::hx::CppiaLoadedModule __scriptable_cppia_from_data(Array<unsigned char> inBytes);
void __scriptable_load_neko_bytes(Array<unsigned char> inBytes);
void __scriptable_load_abc(Array<unsigned char> inBytes);
#if (HXCPP_API_LEVEL >= 330)
#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, & class##_scriptable )
#else
#define HX_SCRIPTABLE_REGISTER_INTERFACE(name,class) \
hx::ScriptableRegisterInterface( HX_CSTRING(name), __scriptableFunctions, &typeid(class), class##__scriptable::__script_create )
#endif
#define HX_SCRIPTABLE_REGISTER_CLASS(name,class) \
hx::ScriptableRegisterClass( HX_CSTRING(name), (int)offsetof(class##__scriptable,__scriptVTable) + sizeof(void *), __scriptableFunctions, class##__scriptable::__script_create, class##__scriptable::__script_construct )
#ifdef HXCPP_VISIT_ALLOCS
#define SCRIPTABLE_VISIT_FUNCTION \
void __Visit(HX_VISIT_PARAMS) { super::__Visit(HX_VISIT_ARG); hx::ScriptableVisit(__scriptVTable[-1],this,HX_VISIT_ARG); }
#else
#define SCRIPTABLE_VISIT_FUNCTION
#endif
#define HX_DEFINE_SCRIPTABLE(ARG_LIST) \
inline void *operator new( size_t inSize, int inExtraDataSize ) \
{ \
return hx::InternalNew(inSize + inExtraDataSize,true); \
} \
inline void operator delete(void *,int) {} \
public: \
void **__scriptVTable; \
static hx::Object *__script_create(void **inVTable, int inExtra) { \
__ME *result = new (inExtra) __ME(); \
result->__scriptVTable = inVTable; \
return result; } \
void ** __GetScriptVTable() { return __scriptVTable; } \
::String toString() { if (__scriptVTable[0] ) \
{ hx::CppiaCtx *ctx = hx::CppiaCtx::getCurrent(); hx::AutoStack a(ctx); ctx->pushObject(this); return ctx->runString(__scriptVTable[0]); } \
else return __superString::toString(); } \
::String __ToString() const { return hx::ScriptableToString(__scriptVTable[-1]); } \
hx::Class __GetClass() const { return hx::ScriptableGetClass(__scriptVTable[-1]); } \
int __GetType() const { return hx::ScriptableGetType(__scriptVTable[-1]); } \
void __Mark(HX_MARK_PARAMS) { super::__Mark(HX_MARK_ARG); hx::ScriptableMark(__scriptVTable[-1],this,HX_MARK_ARG); } \
SCRIPTABLE_VISIT_FUNCTION
#define HX_DEFINE_SCRIPTABLE_INTERFACE \
void **__scriptVTable; \
Dynamic mDelegate; \
hx::Object *__GetRealObject() { return mDelegate.mPtr; } \
SCRIPTABLE_VISIT_FUNCTION \
void ** __GetScriptVTable() { return __scriptVTable; } \
public: \
static hx::Object *__script_create(void **inVTable,hx::Object *inDelegate) { \
__ME *result = new __ME(); \
result->__scriptVTable = inVTable; \
result->mDelegate = inDelegate; \
return result; }
#define HX_DEFINE_SCRIPTABLE_DYNAMIC \
\
hx::Val __Field(const ::String &inName,hx::PropertyAccess inCallProp) \
{ Dynamic result; if (hx::ScriptableField(this,inName,inCallProp,result)) return result; return super::__Field(inName,inCallProp); } \
Float __INumField(int inFieldID) \
{ Float result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__INumField(inFieldID); } \
Dynamic __IField(int inFieldID) \
{ Dynamic result; if (hx::ScriptableField(this,inFieldID,hx::paccAlways,result)) return result; return super::__IField(inFieldID); } \
hx::Val __SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp) \
{ \
Dynamic value; \
if (hx::ScriptableSetField(this, inName, inValue,inCallProp,value)) \
return value; \
return super::__SetField(inName,inValue,inCallProp); \
} \
void __GetFields(Array< ::String> &outFields) \
{ super::__GetFields(outFields); hx::ScriptableGetFields(this,outFields); }
#endif

752
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StackContext.h Normal file
View File

@ -0,0 +1,752 @@
#ifndef HX_STACK_CONTEXT_H
#define HX_STACK_CONTEXT_H
#include "QuickVec.h"
#ifdef HXCPP_SINGLE_THREADED_APP
#define HX_CTX_GET ::hx::gMainThreadContext
#else
#define HX_CTX_GET ((::hx::StackContext *)::hx::tlsStackContext)
#endif
// Set:
// HXCPP_STACK_LINE if stack line numbers need to be tracked
// HXCPP_STACK_TRACE if stack frames need to be tracked
// Keep track of lines - more accurate stack traces for exceptions, also
// needed for the debugger
#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined(HXCPP_STACK_LINE)
#define HXCPP_STACK_LINE
#endif
// Do we need to keep a stack trace - for basic exception handelling, also needed for the debugger
// At a minimum, you can track the functions calls and nothing else
#if (defined(HXCPP_STACK_LINE) || defined(HXCPP_TELEMETRY) || defined(HXCPP_PROFILER) || defined(HXCPP_DEBUG)) && !defined(HXCPP_STACK_TRACE)
#define HXCPP_STACK_TRACE
#endif
#if defined(HXCPP_STACK_TRACE) && defined(HXCPP_SCRIPTABLE)
#define HXCPP_STACK_SCRIPTABLE
#endif
// HXCPP_DEBUG_HASH == HXCPP_DEBUGGER
// HXCPP_STACK_VARS == HXCPP_DEBUGGER
// HX_STACKFRAME(pos) - tracks position according to define. May be optimized away.
// HX_GC_STACKFRAME(pos) - tracks position according to define, but is never optimized away
// HX_JUST_GC_STACKFRAME - never tracks position, never optimized away
// Setup the _hx_stackframe variable
#ifdef HXCPP_STACK_TRACE
// Setup the 'HX_DEFINE_STACK_FRAME' 'HX_LOCAL_STACK_FRAME' macro.
// This will be empty, just track functions(release), track functions and lines(debug) or track everything (debugger)
#define HX_DECLARE_STACK_FRAME(name) extern ::hx::StackPosition name;
#ifdef HXCPP_STACK_LINE
#ifdef HXCPP_DEBUGGER
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
lineNumber, fileHash ) \
::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber, \
classFunctionHash, fileHash);
#else
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
lineNumber, fileHash ) \
::hx::StackPosition varName(className, functionName, fullName, fileName, lineNumber);
#endif
#else
#define HX_DEFINE_STACK_FRAME(varName, className, functionName, classFunctionHash, fullName,fileName, \
lineNumber, fileHash ) \
::hx::StackPosition varName(className, functionName, fullName, fileName);
#endif
#define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h) static HX_DEFINE_STACK_FRAME(a,b,c,d,e,f,g,h)
// Haxe < 330 does not create position pointers, and we must use a local one.
// This code will hst the 'HX_STACK_FRAME' macro
#define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash ) \
::hx::StackFrame _hx_stackframe(&__stackPosition);
// Newer code will use the HX_STACKFRAME macro
#define HX_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
#define HX_GC_STACKFRAME(pos) ::hx::StackFrame _hx_stackframe(pos);
// Must record the stack state at the catch
#define HX_STACK_BEGIN_CATCH __hxcpp_stack_begin_catch();
#define HX_JUST_GC_STACKFRAME ::hx::JustGcStackFrame _hx_stackframe;
#define HX_CTX _hx_stackframe.ctx
#else
// No need to track frame
#define HX_DECLARE_STACK_FRAME(name)
#define HX_STACK_BEGIN_CATCH
#define HX_DEFINE_STACK_FRAME(__stackPosition, className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
#define HX_LOCAL_STACK_FRAME(a,b,c,d,e,f,g,h)
#define HX_STACK_FRAME(className, functionName, classFunctionHash, fullName,fileName, lineNumber, fileHash )
#define HX_STACKFRAME(pos)
#define HX_JUST_GC_STACKFRAME ::hx::StackContext *_hx_ctx = HX_CTX_GET;
#define HX_GC_STACKFRAME(pos) HX_JUST_GC_STACKFRAME
#define HX_CTX _hx_ctx
#endif
#define HX_GC_CTX HX_CTX
// Setup debugger catchable and variable macros...
#ifdef HXCPP_DEBUGGER
// Emitted at the beginning of every instance fuction. ptr is "this".
// Only if stack variables are to be tracked
#define HX_STACK_THIS(ptr) ::hx::StackThis __stackthis(_hx_stackframe.variables, ptr);
// Emitted at the beginning of every function that takes arguments.
// name is the name of the argument.
// For the lifetime of this object, the argument will be in the [arguments]
// list of the stack frame in which the arg was declared
// Only if stack variables are to be tracked
#define HX_STACK_ARG(cpp_var, haxe_name) \
::hx::StackVariable __stackargument_##cpp_var(_hx_stackframe.variables, true, haxe_name, &cpp_var);
// Emitted whenever a Haxe value is pushed on the stack. cpp_var is the local
// cpp variable, haxe_name is the name that was used in haxe for it
// Only if stack variables are to be tracked
#define HX_STACK_VAR(cpp_var, haxe_name) \
::hx::StackVariable __stackvariable_##cpp_var(_hx_stackframe.variables, false, haxe_name, &cpp_var);
#define HX_STACK_CATCHABLE(T, n) \
hx::StackCatchable __stackcatchable_##n \
(_hx_stackframe, reinterpret_cast<T *>(&_hx_stackframe));
// If HXCPP_DEBUGGER is enabled, then a throw is checked to see if it
// can be caught and if not, the debugger is entered. Otherwise, the
// throw proceeds as normal.
#define HX_STACK_DO_THROW(e) __hxcpp_dbg_checkedThrow(e)
#define HX_STACK_DO_RETHROW(e) __hxcpp_dbg_checkedRethrow(e)
#define HX_VAR(type,name) type name; HX_STACK_VAR(name, #name)
#define HX_VARI(type,name) type name; HX_STACK_VAR(name, #name) name
#define HX_VAR_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName)
#define HX_VARI_NAME(type,name,dbgName) type name; HX_STACK_VAR(name, dbgName) name
#else // Non-debugger versions. Just stub-out.
#define HX_STACK_THIS(ptr)
#define HX_STACK_ARG(cpp_var, haxe_name)
#define HX_STACK_VAR(cpp_var, haxe_name)
#define HX_STACK_CATCHABLE(T, n)
#define HX_VAR(type,name) type name
#define HX_VARI(type,name) type name
#define HX_VAR_NAME(type,name,dbgName) type name
#define HX_VARI_NAME(type,name,dbgName) type name
// Just throw - move to hx::Throw function?
#define HX_STACK_DO_THROW(e) ::hx::Throw(e)
#define HX_STACK_DO_RETHROW(e) ::hx::Rethrow(e)
#endif // HXCPP_STACK_VARS
// Emitted after every Haxe line. number is the original Haxe line number.
// Only if stack lines are to be tracked
#ifdef HXCPP_STACK_LINE
// If the debugger is enabled, must check for a breakpoint at every line.
#ifdef HXCPP_DEBUGGER
#define HX_STACK_LINE(number) \
_hx_stackframe.lineNumber = number; \
/* This is incorrect - a read memory barrier is needed here. */ \
/* For now, just live with the exceedingly rare cases where */ \
/* breakpoints are missed */ \
if (::hx::gShouldCallHandleBreakpoints) { \
__hxcpp_on_line_changed(_hx_stackframe.ctx); \
}
#define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
#else
// Just set it
#define HX_STACK_LINE(number) _hx_stackframe.lineNumber = number;
#define HX_STACK_LINE_QUICK(number) _hx_stackframe.lineNumber = number;
#endif
#else
#define HX_STACK_LINE(number)
#define HX_STACK_LINE_QUICK(number)
#endif
// For tidier generated code
#define HXLINE(number) HX_STACK_LINE(number)
#define HXDLIN(number)
// To support older versions of the haxe compiler that emit HX_STACK_PUSH
// instead of HX_STACK_FRAME. If the old haxe compiler is used with this
// new debugger implementation, className.functionName breakpoints will
// not work, and stack reporting will be a little weird. If you want to
// use debugging, you really should upgrade to a newer haxe compiler.
#undef HX_STACK_PUSH
#define HX_STACK_PUSH(fullName, fileName, lineNumber) \
HX_STACK_FRAME("", fullName, 0, fullName, fileName, lineNumber, 0)
#if defined(HXCPP_STACK_TRACE) || defined(HXCPP_TELEMETRY)
#define HXCPP_STACK_IDS
#endif
namespace hx
{
class StackFrame;
struct StackContext;
class Profiler;
void profDestroy(Profiler *);
void profAttach(Profiler *, StackContext *);
void profDetach(Profiler *, StackContext *);
void profSample(Profiler *, StackContext *inContext);
class Telemetry;
Telemetry *tlmCreate(StackContext *);
void tlmDestroy(Telemetry *);
void tlmAttach(Telemetry *, StackContext *);
void tlmDetach(Telemetry *);
void tlmSampleEnter(Telemetry *, StackFrame *inFrame);
void tlmSampleExit(Telemetry *);
class DebuggerContext;
DebuggerContext *dbgCtxCreate(StackContext *);
void dbgCtxDestroy(DebuggerContext *);
void dbgCtxAttach(DebuggerContext *, StackContext *);
void dbgCtxDetach(DebuggerContext *);
void dbgCtxEnable(DebuggerContext *, bool inEnable);
struct scriptCallable;
class StackVariable;
class StackCatchable;
template<typename T> struct Hash;
struct TWeakStringSet;
typedef Hash<TWeakStringSet> WeakStringSet;
extern const char* EXTERN_CLASS_NAME;
#ifdef HXCPP_DEBUGGER
extern volatile bool gShouldCallHandleBreakpoints;
// These must match the values present in cpp.vm.Debugger
enum DebugStatus
{
DBG_STATUS_INVALID = 0, // Not present or needed in cpp.vm.Debugger
DBG_STATUS_RUNNING = 1,
DBG_STATUS_STOPPED_BREAK_IMMEDIATE = 2,
DBG_STATUS_STOPPED_BREAKPOINT = 3,
DBG_STATUS_STOPPED_UNCAUGHT_EXCEPTION = 4,
DBG_STATUS_STOPPED_CRITICAL_ERROR = 5
};
enum ExecutionTrace
{
exeTraceOff = 0,
exeTraceFuncs = 1,
exeTraceLines = 2,
};
extern ExecutionTrace sExecutionTrace;
#endif
class StackPosition
{
public:
// These are constant during the lifetime of the stack frame
const char *className;
const char *functionName;
const char *fullName; // this is className.functionName - used for profiler
const char *fileName;
int firstLineNumber;
#if defined(HXCPP_STACK_SCRIPTABLE)
// Information about the current cppia function
struct ScriptCallable *scriptCallable;
#endif
// These are only used if HXCPP_DEBUGGER is defined
#ifdef HXCPP_DEBUGGER
int fileHash;
int classFuncHash;
#else
enum { fileHash = 0, classFuncHash=0 };
#endif
inline StackPosition() { }
// The constructor automatically adds the StackFrame to the list of
// stack frames for the current thread
inline StackPosition(const char *inClassName, const char *inFunctionName,
const char *inFullName, const char *inFileName
#ifdef HXCPP_STACK_LINE
, int inLineNumber
#endif
#ifdef HXCPP_DEBUGGER
,int inClassFunctionHash, int inFileHash
#endif
)
: className(inClassName), functionName(inFunctionName)
,fullName(inFullName), fileName(inFileName)
#ifdef HXCPP_DEBUGGER
,classFuncHash(inClassFunctionHash)
,fileHash(inFileHash)
#endif
#ifdef HXCPP_STACK_LINE
,firstLineNumber(inLineNumber)
#endif
{
#if defined(HXCPP_STACK_SCRIPTABLE)
// Information about the current cppia function
scriptCallable = 0;
#endif
}
};
#ifdef HXCPP_STACK_TRACE
struct ExceptionStackFrame
{
#ifdef HXCPP_STACK_LINE
int line;
#endif
#if HXCPP_API_LEVEL > 330
const hx::StackPosition *position;
#else
const char *className;
const char *functionName;
const char *fileName;
#endif
ExceptionStackFrame(const StackFrame &inFrame);
::String format(bool inForDisplay);
::String toDisplay();
::String toString();
};
#endif
#ifdef HXCPP_SCRIPTABLE
enum
{
bcrBreak = 0x01,
bcrContinue = 0x02,
bcrReturn = 0x04,
bcrLoop = (bcrBreak | bcrContinue),
};
#endif
struct MarkChunk
{
enum { SIZE = 62 };
enum { OBJ_ARRAY_JOB = -1 };
inline MarkChunk() : count(0), next(0) { }
int count;
union
{
hx::Object *stack[SIZE];
struct
{
hx::Object **arrayBase;
int arrayElements;
};
};
MarkChunk *next;
inline void push(Object *inObj)
{
stack[count++] = inObj;
}
inline hx::Object *pop()
{
if (count)
return stack[--count];
return 0;
}
MarkChunk *swapForNew();
};
struct StackContext : public hx::ImmixAllocator
{
#ifdef HXCPP_STACK_IDS
int mThreadId;
#endif
#ifdef HXCPP_STACK_TRACE
hx::QuickVec<StackFrame *> mStackFrames;
hx::QuickVec<hx::ExceptionStackFrame> mExceptionStack;
// Updated only when a thrown exception unwinds the stack
bool mIsUnwindingException;
#ifdef HXCPP_STACK_SCRIPTABLE
// TODO - combine CppaCtx and StackContext
#endif
#ifdef HXCPP_DEBUGGER
DebuggerContext *mDebugger;
#endif
#ifdef HXCPP_PROFILER
// Profiling support
Profiler *mProfiler;
#endif
#endif
#ifdef HXCPP_TELEMETRY
// Telemetry support
Telemetry *mTelemetry;
#endif
#ifdef HXCPP_COMBINE_STRINGS
WeakStringSet *stringSet;
#endif
#ifdef HXCPP_GC_GENERATIONAL
MarkChunk *mOldReferrers;
inline void pushReferrer(hx::Object *inObj)
{
// If collector is running on non-generational mode, mOldReferrers will be null
if (mOldReferrers)
{
mOldReferrers->push(inObj);
if (mOldReferrers->count==MarkChunk::SIZE)
mOldReferrers = mOldReferrers->swapForNew();
}
}
#endif
#ifdef HXCPP_CATCH_SEGV
#ifdef _MSC_VER
_se_translator_function mOldSignalFunc;
#else
void (*mOldSignalFunc)(int);
#endif
#endif
StackContext();
~StackContext();
void onThreadAttach();
void onThreadDetach();
#ifdef HXCPP_STACK_TRACE // {
void tracePosition();
// Note that the stack frames are manipulated without holding any locks.
// This is because the manipulation of stack frames can only be done by
// the thread that "owns" that stack frame. The only other contention on
// the call stack is from calls to GetThreadInfo() and GetThreadInfos(),
// and these should only be called when the thread for which the call
// stack is being acquired is stopped in a breakpoint anyway, thus there
// can be no contention on the contents of the CallStack in that case
// either.
inline void pushFrame(StackFrame *inFrame)
{
#ifdef HXCPP_PROFILER
if (mProfiler)
profSample(mProfiler,this);
#endif
#ifdef HXCPP_TELEMETRY
if (mTelemetry)
tlmSampleEnter(mTelemetry,inFrame);
#endif
mIsUnwindingException = false;
mStackFrames.push(inFrame);
#ifdef HXCPP_DEBUGGER
if (sExecutionTrace!=exeTraceOff)
tracePosition();
#endif
}
inline void popFrame(StackFrame *inFrame)
{
#ifdef HXCPP_TELEMETRY
if (mTelemetry)
tlmSampleExit(mTelemetry);
#endif
if (mIsUnwindingException)
{
// Use default operator=
mExceptionStack.push( *inFrame );
}
mStackFrames.pop_back();
}
void getCurrentCallStackAsStrings(Array<String> result, bool skipLast);
void getCurrentExceptionStackAsStrings(Array<String> result);
StackFrame *getCurrentStackFrame() { return mStackFrames.back(); }
StackFrame *getStackFrame(int inIndex) { return mStackFrames[inIndex]; }
int getDepth() const { return mStackFrames.size(); }
inline const char *getFullNameAtDepth(int depth) const;
void dumpExceptionStack();
// Called when a throw occurs
void setLastException();
void pushLastException();
// Called when a catch block begins to be executed. hxcpp wants to track
// the stack back through the catches so that it can be dumped if
// uncaught. If inAll is true, the entire stack is captured immediately.
// If inAll is false, only the last stack frame is captured.
void beginCatch(bool inAll);
#endif // } HXCPP_STACK_TRACE
#ifdef HXCPP_DEBUGGER
void enableCurrentThreadDebugging(bool inEnable)
{
dbgCtxEnable(mDebugger,inEnable);
}
#endif
static inline StackContext *getCurrent()
{
return HX_CTX_GET;
}
#ifdef HXCPP_STACK_IDS
static void getAllStackIds( QuickVec<int> &outIds );
static StackContext *getStackForId(int id);
#endif
#ifdef HXCPP_SCRIPTABLE
unsigned char *stack;
unsigned char *pointer;
unsigned char *frame;
class Object *exception;
unsigned int breakContReturn;
int byteMarkId;
template<typename T>
void push(T inValue)
{
*(T *)pointer = inValue;
pointer += sizeof(T);
}
unsigned char *stackAlloc(int inSize)
{
unsigned char *p = pointer;
pointer += inSize;
return p;
}
void stackFree(int inSize)
{
pointer -= inSize;
}
int getFrameSize() const { return pointer-frame; }
int runInt(void *vtable);
Float runFloat(void *vtable);
String runString(void *vtable);
void runVoid(void *vtable);
Dynamic runObject(void *vtable);
hx::Object *runObjectPtr(void *vtable);
void push(bool &inValue) { *(int *)pointer = inValue; pointer += sizeof(int); }
inline void pushBool(bool b) { *(int *)pointer = b; pointer += sizeof(int); }
inline void pushInt(int i) { *(int *)pointer = i; pointer += sizeof(int); }
inline void pushFloat(Float f);
inline void pushString(const String &s);
inline void pushObject(Dynamic d);
inline void returnFloat(Float f);
inline void returnString(const String &s);
inline void returnObject(Dynamic d);
inline hx::Object *getThis(bool inCheckPtr=true);
inline void returnBool(bool b) { *(int *)frame = b; }
inline void returnInt(int i) { *(int *)frame = i; }
inline bool getBool(int inPos=0) { return *(bool *)(frame+inPos); }
inline int getInt(int inPos=0) { return *(int *)(frame+inPos); }
inline Float getFloat(int inPos=0);
inline String getString(int inPos=0);
inline Dynamic getObject(int inPos=0);
inline hx::Object *getObjectPtr(int inPos=0) { return *(hx::Object **)(frame+inPos); }
void breakFlag() { breakContReturn |= bcrBreak; }
void continueFlag() { breakContReturn |= bcrContinue; }
void returnFlag() { breakContReturn |= bcrReturn; }
#endif
};
typedef StackContext CppiaCtx;
class StackFrame
{
public:
StackContext *ctx;
#ifdef HXCPP_STACK_TRACE // {
const StackPosition *position;
#ifdef HXCPP_STACK_LINE
// Current line number, changes during the lifetime of the stack frame.
// Only updated if HXCPP_STACK_LINE is defined.
int lineNumber;
#ifdef HXCPP_DEBUGGER
// Function arguments and local variables in reverse order of their
// declaration. If a variable name is in here twice, the first version is
// the most recently scoped one and should be used. Only updated if
// HXCPP_DEBUGGER is defined.
StackVariable *variables;
// The list of types that can be currently caught in the stack frame.
StackCatchable *catchables;
#endif
#endif
// The constructor automatically adds the StackFrame to the list of
// stack frames for the current thread
inline StackFrame(const StackPosition *inPosition
) : position(inPosition)
{
#ifdef HXCPP_STACK_LINE
lineNumber = inPosition->firstLineNumber;
#ifdef HXCPP_DEBUGGER
variables = 0;
catchables = 0;
#endif
#endif
ctx = HX_CTX_GET;
ctx->pushFrame(this);
}
// The destructor automatically removes the StackFrame from the list of
// stack frames for the current thread
~StackFrame()
{
ctx->popFrame(this);
}
::String toString();
::String toDisplay();
#else // } !HXCPP_STACK_TRACE {
// Release version only has ctx
inline StackFrame()
{
ctx = HX_CTX_GET;
}
#endif // }
};
#ifdef HXCPP_STACK_TRACE
const char *StackContext::getFullNameAtDepth(int depth) const
{
return mStackFrames[depth]->position->fullName;
}
#endif
class JustGcStackFrame
{
public:
StackContext *ctx;
inline JustGcStackFrame() : ctx(HX_CTX_GET) { }
};
} // end namespace hx
// Some functions used by AdvancedDebug.cpp
// Returns the thread number of the calling thread
HXCPP_EXTERN_CLASS_ATTRIBUTES
int __hxcpp_GetCurrentThreadNumber();
// Called by the main function when an uncaught exception occurs to dump
// the stack leading to the exception
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hx_dump_stack();
// The macro HX_STACK_BEGIN_CATCH, which is emitted at the beginning of every
// catch block, calls this in debug mode to let the debugging system know that
// a catch block has been entered
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_stack_begin_catch();
// Last chance to throw an exception for null-pointer access
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_set_critical_error_handler(Dynamic inHandler);
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_execution_trace(int inLevel);
// Used by debug breakpoints and execution trace
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_set_stack_frame_line(int);
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_on_line_changed(hx::StackContext *);
HXCPP_EXTERN_CLASS_ATTRIBUTES
void __hxcpp_set_debugger_info(const char **inAllClasses, const char **inFullPaths);
void __hxcpp_dbg_getScriptableVariables(hx::StackFrame *stackFrame, ::Array< ::Dynamic> outNames);
bool __hxcpp_dbg_getScriptableValue(hx::StackFrame *stackFrame, String inName, ::Dynamic &outValue);
bool __hxcpp_dbg_setScriptableValue(hx::StackFrame *StackFrame, String inName, ::Dynamic inValue);
#endif // HX_STACK_CTX_H

932
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdLibs.h Normal file
View File

@ -0,0 +1,932 @@
#ifndef HX_STDLIBS_H
#define HX_STDLIBS_H
// --- Resource -------------------------------------------------------------
namespace haxe {
namespace ds {
class HXCPP_CLASS_ATTRIBUTES StringMap_obj;
}
}
namespace hx
{
struct Resource
{
String mName;
int mDataLength;
unsigned char *mData;
bool operator<(const Resource &inRHS) const { return mName < inRHS.mName; }
};
Resource *GetResources();
HXCPP_EXTERN_CLASS_ATTRIBUTES
void RegisterResources(hx::Resource *inResources);
struct AnyCast
{
template<typename T>
explicit AnyCast(T* inPtr) : mPtr((void *)inPtr) { }
template<typename T>
operator T*() const { return (T*)mPtr; }
void *mPtr;
};
} // end namespace hx
Array<String> __hxcpp_resource_names();
String __hxcpp_resource_string(String inName);
Array<unsigned char> __hxcpp_resource_bytes(String inName);
// System access
Array<String> __get_args();
double __time_stamp();
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_print_string(const String &inV);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_println_string(const String &inV);
template<typename T> inline void __hxcpp_println(T inV)
{
Dynamic d(inV);
__hxcpp_println_string(d);
}
// Specialization that does not need dynamic boxing
template<> inline void __hxcpp_println(String inV)
{
__hxcpp_println_string(inV);
}
template<typename T> inline void __hxcpp_print(T inV)
{
Dynamic d(inV);
__hxcpp_print_string(d);
}
// Specialization that does not need dynamic boxing
template<> inline void __hxcpp_print(String inV)
{
__hxcpp_print_string(inV);
}
HXCPP_EXTERN_CLASS_ATTRIBUTES void __trace(Dynamic inPtr, Dynamic inData);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_exit(int inExitCode);
void __hxcpp_stdlibs_boot();
HXCPP_EXTERN_CLASS_ATTRIBUTES int hxcpp_alloc_kind();
// --- Maths ---------------------------------------------------------
double __hxcpp_drand();
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_irand(int inMax);
// --- Casting/Converting ---------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __instanceof(const Dynamic &inValue, const Dynamic &inType);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int__(double x);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __hxcpp_same_closure(Dynamic &inF1,Dynamic &inF2);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_parse_int(const String &inString);
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_float(const String &inString);
HXCPP_EXTERN_CLASS_ATTRIBUTES double __hxcpp_parse_substr_float(const String &inString, int start, int len);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_parse_substr_int(const String &inString, int start=0, int len=-1);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __hxcpp_create_var_args(Dynamic &inArrayFunc);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_set_float_format(String inFormat);
inline int _hx_idiv(int inNum,int inDenom) { return inNum/inDenom; }
inline int _hx_imod(int inNum,int inDenom) { return inNum%inDenom; }
inline int _hx_cast_int(int inX) { return inX; }
inline int _hx_fast_floor(double inX) {
union Cast
{
double d;
long l;
};
Cast c;
c.d = (inX-0.5) + 6755399441055744.0;
return c.l;
}
// --- CFFI helpers ------------------------------------------------------------------
// Used for accessing object fields by integer ID, rather than string ID.
// Used mainly for neko ndll interaction.
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_field_to_id( const char *inField );
HXCPP_EXTERN_CLASS_ATTRIBUTES const String &__hxcpp_field_from_id( int f );
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_register_prim(const HX_CHAR *inName,void *inFunc);
// Get function pointer from dll file
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __loadprim(String inLib, String inPrim,int inArgCount);
HXCPP_EXTERN_CLASS_ATTRIBUTES void *__hxcpp_get_proc_address(String inLib, String inPrim,bool inNdll, bool inQuietFail=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_run_dll(String inLib, String inPrim);
// Can assign to function pointer without error
inline hx::AnyCast __hxcpp_cast_get_proc_address(String inLib, String inPrim,bool inQuietFail=false)
{
return hx::AnyCast(__hxcpp_get_proc_address(inLib,inPrim,false,inQuietFail));
}
HXCPP_EXTERN_CLASS_ATTRIBUTES int __hxcpp_unload_all_libraries();
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_push_dll_path(String inPath);
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_dll_extension();
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_bin_dir();
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_get_kind(Dynamic inObject);
// Loading functions via name (dummy return value)
// --- haxe.io.BytesData ----------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_bytes_of_string(Array<unsigned char> &outBytes,const String &inString);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_string_of_bytes(Array<unsigned char> &inBytes,String &outString,int pos,int len,bool inCopyPointer=false);
// UTF8 processing
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_array_to_utf8_string(Array<int> &inChars,int inFirst=0, int inLen=-1);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> __hxcpp_utf8_string_to_char_array(String &inString);
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_char_bytes_to_utf8_string(String &inBytes);
HXCPP_EXTERN_CLASS_ATTRIBUTES String __hxcpp_utf8_string_to_char_bytes(String &inUTF8);
#ifdef HXCPP_GC_GENERATIONAL
#define HX_MAP_THIS this, h
#define HX_MAP_THIS_ this,
#define HX_MAP_THIS_ARG hx::Object *owner, Dynamic &ioHash
#else
#define HX_MAP_THIS h
#define HX_MAP_THIS_
#define HX_MAP_THIS_ARG Dynamic &ioHash
#endif
// --- HashRoot ---------------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES int __root_hash_size(Dynamic *rtHash);
// --- IntHash ----------------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object *__int_hash_create() { return 0; }
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set(HX_MAP_THIS_ARG,int inKey,const Dynamic &value);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int_hash_exists(Dynamic &hash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int_hash_remove(Dynamic &hash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> __int_hash_keys(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int_hash_values(Dynamic &hash);
// Typed IntHash access...
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_int(HX_MAP_THIS_ARG,int inKey,int inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_string(HX_MAP_THIS_ARG,int inKey,::String inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_float(HX_MAP_THIS_ARG,int inKey,Float inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_set_int64(HX_MAP_THIS_ARG,int inKey,cpp::Int64 inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int_hash_to_string(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int_hash_clear(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int_hash_get(Dynamic inHash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int_hash_get_int(Dynamic inHash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int_hash_get_string(Dynamic inHash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __int_hash_get_float(Dynamic inHash,int inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __int_hash_get_int64(Dynamic inHash,int inKey);
inline bool __int_hash_get_bool(Dynamic inHash,int inKey) { return __int_hash_get_int(inHash,inKey); }
// --- Int64Hash -----------------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES inline hx::Object *__int64_hash_create() { return 0; }
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set(HX_MAP_THIS_ARG,cpp::Int64 inKey,const Dynamic &value);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int64_hash_exists(Dynamic &hash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __int64_hash_remove(Dynamic &hash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<cpp::Int64> __int64_hash_keys(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int64_hash_values(Dynamic &hash);
// Typed IntHash access...
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_int(HX_MAP_THIS_ARG,cpp::Int64 inKey,int inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_string(HX_MAP_THIS_ARG,cpp::Int64 inKey,::String inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_float(HX_MAP_THIS_ARG,cpp::Int64 inKey,Float inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_set_int64(HX_MAP_THIS_ARG,cpp::Int64 inKey,cpp::Int64 inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int64_hash_to_string(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __int64_hash_clear(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __int64_hash_get(Dynamic inHash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __int64_hash_get_int(Dynamic inHash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __int64_hash_get_string(Dynamic inHash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __int64_hash_get_float(Dynamic inHash,cpp::Int64 inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __int64_hash_get_int64(Dynamic inHash,cpp::Int64 inKey);
inline bool __int64_hash_get_bool(Dynamic inHash,cpp::Int64 inKey) { return __int64_hash_get_int(inHash,inKey); }
// --- StringHash ----------------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set(HX_MAP_THIS_ARG,String inKey,const Dynamic &value,bool inForceDynamic=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __string_hash_exists(Dynamic &hash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __string_hash_remove(Dynamic &hash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::String> __string_hash_keys(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_values(Dynamic &hash);
// Typed StringHash access...
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_int(HX_MAP_THIS_ARG,String inKey,int inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_string(HX_MAP_THIS_ARG,String inKey,::String inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_float(HX_MAP_THIS_ARG,String inKey,Float inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_set_int64(HX_MAP_THIS_ARG,String inKey,cpp::Int64 inValue);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_map_substr(HX_MAP_THIS_ARG,String inKey,int inStart, int inLength);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_to_string(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_to_string_raw(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __string_hash_clear(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_get(Dynamic inHash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __string_hash_get2(haxe::ds::StringMap_obj* map,String* inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __string_hash_get_int(Dynamic inHash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __string_hash_get_string(Dynamic inHash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __string_hash_get_float(Dynamic inHash,String inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __string_hash_get_int64(Dynamic inHash,String inKey);
inline bool __string_hash_get_bool(Dynamic inHash,String inKey) { return __string_hash_get_int(inHash,inKey); }
// --- ObjectHash ----------------------------------------------------------------------
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set(HX_MAP_THIS_ARG,Dynamic inKey,const Dynamic &value,bool inWeakKey=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __object_hash_exists(Dynamic &hash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool __object_hash_remove(Dynamic &hash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array< ::Dynamic> __object_hash_keys(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __object_hash_values(Dynamic &hash);
// Typed ObjectHash access...
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_int(HX_MAP_THIS_ARG,Dynamic inKey,int inValue,bool inWeakKey=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_string(HX_MAP_THIS_ARG,Dynamic inKey,::String inValue,bool inWeakKey=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_float(HX_MAP_THIS_ARG,Dynamic inKey,Float inValue,bool inWeakKey=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_set_int64(HX_MAP_THIS_ARG,Dynamic inKey,cpp::Int64 inValue,bool inWeakKey=false);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __object_hash_to_string(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES void __object_hash_clear(Dynamic &hash);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic __object_hash_get(Dynamic inHash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES int __object_hash_get_int(Dynamic inHash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES ::String __object_hash_get_string(Dynamic inHash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float __object_hash_get_float(Dynamic inHash,Dynamic inKey);
HXCPP_EXTERN_CLASS_ATTRIBUTES cpp::Int64 __object_hash_get_int64(Dynamic inHash,Dynamic inKey);
inline bool __object_hash_get_bool(Dynamic inHash,Dynamic inKey) { return __object_hash_get_int(inHash,inKey); }
// --- Date --------------------------------------------------------------------------
// returns Epoch UTC timestamp (in seconds); assumes that input date parts are considered to be in local timezone date/time representation
double __hxcpp_new_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds,int inMilliseconds = 0);
double __hxcpp_utc_date(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds);
int __hxcpp_get_hours(double inSeconds);
int __hxcpp_get_minutes(double inSeconds);
int __hxcpp_get_seconds(double inSeconds);
int __hxcpp_get_year(double inSeconds);
int __hxcpp_get_month(double inSeconds);
int __hxcpp_get_date(double inSeconds);
int __hxcpp_get_day(double inSeconds);
String __hxcpp_to_string(double inSeconds);
double __hxcpp_date_now();
int __hxcpp_get_utc_hours(double inSeconds); /* returns hour part of UTC date/time representation of input time (Epoch, in seconds), 0-23 */
int __hxcpp_get_utc_minutes(double inSeconds); /* returns minutes part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
int __hxcpp_get_utc_seconds(double inSeconds); /* returns seconds part of UTC date/time representation of input time (Epoch, in seconds), 0-59 */
int __hxcpp_get_utc_year(double inSeconds); /* returns year part of UTC date/time representation of input time (Epoch, in seconds) */
int __hxcpp_get_utc_month(double inSeconds); /* returns month part of UTC date/time representation of input time (Epoch, in seconds), 0-January...11-December */
int __hxcpp_get_utc_date(double inSeconds); /* returns day of the month part of UTC date/time representation of input time (Epoch, in seconds), 1-31 */
int __hxcpp_get_utc_day(double inSeconds); /* returns day of the week part of UTC date/time representation of input time (Epoch, in seconds), 0-Sunday...6-Saturday */
String __hxcpp_to_utc_string(double inSeconds); /* same as __hxcpp_to_string but in corresponding UTC format */
int __hxcpp_is_dst(double inSeconds); /* is input time (Epoch UTC timestamp, in seconds)'s local time in DST ? 1 for true, 0 for false */
double __hxcpp_timezone_offset(double inSeconds); /* input time (Epoch UTC timestamp, in seconds)'s local time zone offset from UTC, in seconds */
double __hxcpp_from_utc(int inYear,int inMonth,int inDay,int inHour, int inMin, int inSeconds, int inMilliSeconds); /* returns Epoch timestamp (in seconds); assumes that input date parts are considered to be in UTC date/time representation */
double __hxcpp_time_stamp();
// --- vm/threading --------------------------------------------------------------------
Dynamic __hxcpp_thread_create(Dynamic inFunc);
Dynamic __hxcpp_thread_current();
void __hxcpp_thread_send(Dynamic inThread, Dynamic inMessage);
Dynamic __hxcpp_thread_read_message(bool inBlocked);
bool __hxcpp_is_current_thread(hx::Object *inThread);
Dynamic __hxcpp_mutex_create();
void __hxcpp_mutex_acquire(Dynamic);
bool __hxcpp_mutex_try(Dynamic);
void __hxcpp_mutex_release(Dynamic);
Dynamic __hxcpp_semaphore_create(int);
void __hxcpp_semaphore_acquire(Dynamic);
bool __hxcpp_semaphore_try_acquire(Dynamic, double timeout);
void __hxcpp_semaphore_release(Dynamic);
Dynamic __hxcpp_condition_create(void);
void __hxcpp_condition_acquire(Dynamic);
bool __hxcpp_condition_try_acquire(Dynamic);
void __hxcpp_condition_release(Dynamic);
void __hxcpp_condition_wait(Dynamic);
bool __hxcpp_condition_timed_wait(Dynamic,double);
void __hxcpp_condition_signal(Dynamic);
void __hxcpp_condition_broadcast(Dynamic);
Dynamic __hxcpp_lock_create();
bool __hxcpp_lock_wait(Dynamic inlock,double inTime);
void __hxcpp_lock_release(Dynamic inlock);
Dynamic __hxcpp_deque_create();
void __hxcpp_deque_add(Dynamic q,Dynamic inVal);
void __hxcpp_deque_push(Dynamic q,Dynamic inVal);
Dynamic __hxcpp_deque_pop(Dynamic q,bool block);
Dynamic __hxcpp_tls_get(int inID);
void __hxcpp_tls_set(int inID,Dynamic inVal);
bool _hx_atomic_exchange_if(::cpp::Pointer<cpp::AtomicInt> inPtr, int test, int newVal );
int _hx_atomic_inc(::cpp::Pointer<cpp::AtomicInt> inPtr );
int _hx_atomic_dec(::cpp::Pointer<cpp::AtomicInt> inPtr );
// Assumptions made:
// People are not using 8 year old versions of GCC.
#if defined(__GNUC__) || defined(__clang__)
#define HX_GCC_ATOMICS
#define HX_HAS_ATOMIC 1
#elif defined(_MSC_VER)
#define HX_MSVC_ATOMICS
#define HX_HAS_ATOMIC 1
#include <intrin.h>
#else
#define HX_HAS_ATOMIC 0
#endif
inline int _hx_atomic_add(volatile int *a, int b) {
#if defined(HX_GCC_ATOMICS)
return __atomic_fetch_add(a, b, __ATOMIC_SEQ_CST);
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedExchangeAdd((long volatile *)a, b);
#else
int old = *a;
*a += b;
return old;
#endif
}
inline int _hx_atomic_sub(volatile int *a, int b) {
#if defined(HX_GCC_ATOMICS)
return __atomic_fetch_sub(a, b, __ATOMIC_SEQ_CST);
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedExchangeAdd((long volatile *)a, -b);
#else
int old = *a;
*a -= b;
return old;
#endif
}
inline int _hx_atomic_and(volatile int *a, int b) {
#if defined(HX_GCC_ATOMICS)
return __atomic_fetch_and(a, b, __ATOMIC_SEQ_CST);
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedAnd((long volatile *)a, b);
#else
int old = *a;
*a &= b;
return old;
#endif
}
inline int _hx_atomic_or(volatile int *a, int b) {
#if defined(HX_GCC_ATOMICS)
return __atomic_fetch_or(a, b, __ATOMIC_SEQ_CST);
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedOr((long volatile *)a, b);
#else
int old = *a;
*a |= b;
return old;
#endif
}
inline int _hx_atomic_xor(int *a, int b) {
#if defined(HX_GCC_ATOMICS)
return __atomic_fetch_xor(a, b, __ATOMIC_SEQ_CST);
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedXor((long volatile *)a, b);
#else
int old = *a;
*a ^= b;
return old;
#endif
}
inline int _hx_atomic_compare_exchange(volatile int *a, int expected,
int replacement) {
#if defined(HX_GCC_ATOMICS)
int _expected = expected;
__atomic_compare_exchange(a, &_expected, &replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
return _expected;
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedCompareExchange((long volatile *)a, replacement, expected);
#else
int old = *a;
if(old == expected) {
*a = replacement;
}
return old;
#endif
}
inline int _hx_atomic_exchange(volatile int *a, int replacement) {
#if defined(HX_GCC_ATOMICS)
int ret = 0;
__atomic_exchange(a, &replacement, &ret, __ATOMIC_SEQ_CST);
return ret;
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedExchange((long volatile *)a, replacement);
#else
int old = *a;
*a = replacement;
return old;
#endif
}
inline int _hx_atomic_load(volatile int *a) {
#if defined(HX_GCC_ATOMICS)
int ret = 0;
__atomic_load(a, &ret, __ATOMIC_SEQ_CST);
return ret;
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedXor((long volatile *)a, 0);
#else
return *a;
#endif
}
inline int _hx_atomic_store(volatile int *a, int value) {
#if defined(HX_GCC_ATOMICS)
__atomic_store(a, &value, __ATOMIC_SEQ_CST);
return value;
#elif defined(HX_MSVC_ATOMICS)
_InterlockedExchange((long volatile *)a, value);
return value;
#else
*a = value;
return value;
#endif
}
inline void* _hx_atomic_compare_exchange_ptr(volatile void **a, void *expected, void* replacement) {
#if defined(HX_GCC_ATOMICS)
void* _expected = expected;
__atomic_compare_exchange(a, (volatile void **)&_expected, (volatile void**)&replacement, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
return _expected;
#elif defined(HX_MSVC_ATOMICS)
return _InterlockedCompareExchangePointer((void *volatile *)a, replacement, expected);
#else
void *old = *a;
*a = replacement;
return old;
#endif
}
inline void* _hx_atomic_compare_exchange_cast_ptr(void *a, void *expected, void *replacement) {
return _hx_atomic_compare_exchange_ptr((volatile void **)a, expected, replacement);
}
Array<String> __hxcpp_get_call_stack(bool inSkipLast);
Array<String> __hxcpp_get_exception_stack();
#define HXCPP_HAS_CLASSLIST
Array<String> __hxcpp_get_class_list();
// --- Profile -------------------------------------------------------------------
void __hxcpp_start_profiler(::String inDumpFile);
void __hxcpp_stop_profiler();
// --- Memory --------------------------------------------------------------------------
inline void __hxcpp_align_set_float32( unsigned char *base, int addr, float v)
{
#ifdef HXCPP_ALIGN_FLOAT
if (addr & 3)
{
const unsigned char *src = (const unsigned char *)&v;
unsigned char *dest = base + addr;
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
dest[3] = src[3];
}
else
#endif
*(float *)(base+addr) = v;
}
inline float __hxcpp_align_get_float32( unsigned char *base, int addr)
{
#ifdef HXCPP_ALIGN_FLOAT
if (addr & 3)
{
float buf;
unsigned char *dest = (unsigned char *)&buf;
const unsigned char *src = base + addr;
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
dest[3] = src[3];
return buf;
}
#endif
return *(float *)(base+addr);
}
inline void __hxcpp_align_set_float64( unsigned char *base, int addr, double v)
{
#ifdef HXCPP_ALIGN_FLOAT
if (addr & 3)
{
unsigned char *dest = base + addr;
const unsigned char *src = (const unsigned char *)&v;
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
dest[3] = src[3];
dest[4] = src[4];
dest[5] = src[5];
dest[6] = src[6];
dest[7] = src[7];
}
else
#endif
*(double *)(base + addr) = v;
}
inline double __hxcpp_align_get_float64( unsigned char *base, int addr)
{
#ifdef HXCPP_ALIGN_FLOAT
if (addr & 3)
{
double buf;
unsigned char *dest = (unsigned char *)&buf;
const unsigned char *src = base + addr;
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
dest[3] = src[3];
dest[4] = src[4];
dest[5] = src[5];
dest[6] = src[6];
dest[7] = src[7];
return buf;
}
#endif
return *(double *)(base+addr);
}
// Threadsafe methods - takes buffer
HXCPP_EXTERN_CLASS_ATTRIBUTES void __hxcpp_memory_memset(Array<unsigned char> &inBuffer ,int pos, int len, int value);
inline int __hxcpp_memory_get_byte(Array<unsigned char> inBuffer ,int addr) { return inBuffer->GetBase()[addr]; }
inline double __hxcpp_memory_get_double(Array<unsigned char> inBuffer ,int addr) {
return __hxcpp_align_get_float64((unsigned char *)inBuffer->GetBase(), addr);
}
inline float __hxcpp_memory_get_float(Array<unsigned char> inBuffer ,int addr) {
return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
}
inline int __hxcpp_memory_get_i16(Array<unsigned char> inBuffer ,int addr) { return *(short *)(inBuffer->GetBase()+addr); }
inline int __hxcpp_memory_get_i32(Array<unsigned char> inBuffer ,int addr) { return *(int *)(inBuffer->GetBase()+addr); }
inline int __hxcpp_memory_get_ui16(Array<unsigned char> inBuffer ,int addr) { return *(unsigned short *)(inBuffer->GetBase()+addr); }
inline int __hxcpp_memory_get_ui32(Array<unsigned char> inBuffer ,int addr) { return *(unsigned int *)(inBuffer->GetBase()+addr); }
inline float __hxcpp_memory_get_f32(Array<unsigned char> inBuffer ,int addr) {
return __hxcpp_align_get_float32((unsigned char *)inBuffer->GetBase(), addr);
}
inline void __hxcpp_memory_set_byte(Array<unsigned char> inBuffer ,int addr,int v) { inBuffer->GetBase()[addr] = v; }
inline void __hxcpp_memory_set_double(Array<unsigned char> inBuffer ,int addr,double v) {
return __hxcpp_align_set_float64((unsigned char *)inBuffer->GetBase(), addr,v);
}
inline void __hxcpp_memory_set_float(Array<unsigned char> inBuffer ,int addr,float v) {
return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr,v);
}
inline void __hxcpp_memory_set_i16(Array<unsigned char> inBuffer ,int addr,int v) { *(short *)(inBuffer->GetBase()+addr) = v; }
inline void __hxcpp_memory_set_i32(Array<unsigned char> inBuffer ,int addr,int v) { *(int *)(inBuffer->GetBase()+addr) = v; }
inline void __hxcpp_memory_set_ui16(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned short *)(inBuffer->GetBase()+addr) = v; }
inline void __hxcpp_memory_set_ui32(Array<unsigned char> inBuffer ,int addr,int v) { *(unsigned int *)(inBuffer->GetBase()+addr) = v; }
inline void __hxcpp_memory_set_f32(Array<unsigned char> inBuffer ,int addr,float v) {
return __hxcpp_align_set_float32((unsigned char *)inBuffer->GetBase(), addr, v);
}
// Uses global pointer...
extern unsigned char *__hxcpp_memory;
inline void __hxcpp_memory_clear( ) { __hxcpp_memory = 0; }
inline void __hxcpp_memory_select( Array<unsigned char> inBuffer )
{ __hxcpp_memory= (unsigned char *)inBuffer->GetBase(); }
inline int __hxcpp_memory_get_byte(int addr) { return __hxcpp_memory[addr]; }
inline double __hxcpp_memory_get_double(int addr) { return __hxcpp_align_get_float64(__hxcpp_memory,addr); }
inline float __hxcpp_memory_get_float(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
inline int __hxcpp_memory_get_i16(int addr) { return *(short *)(__hxcpp_memory+addr); }
inline int __hxcpp_memory_get_i32(int addr) { return *(int *)(__hxcpp_memory+addr); }
inline int __hxcpp_memory_get_ui16(int addr) { return *(unsigned short *)(__hxcpp_memory+addr); }
inline int __hxcpp_memory_get_ui32(int addr) { return *(unsigned int *)(__hxcpp_memory+addr); }
inline float __hxcpp_memory_get_f32(int addr) { return __hxcpp_align_get_float32(__hxcpp_memory,addr); }
inline void __hxcpp_memory_set_byte(int addr,int v) { __hxcpp_memory[addr] = v; }
inline void __hxcpp_memory_set_double(int addr,double v) { __hxcpp_align_set_float64(__hxcpp_memory,addr,v); }
inline void __hxcpp_memory_set_float(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
inline void __hxcpp_memory_set_i16(int addr,int v) { *(short *)(__hxcpp_memory+addr) = v; }
inline void __hxcpp_memory_set_i32(int addr,int v) { *(int *)(__hxcpp_memory+addr) = v; }
inline void __hxcpp_memory_set_ui16(int addr,int v) { *(unsigned short *)(__hxcpp_memory+addr) = v; }
inline void __hxcpp_memory_set_ui32(int addr,int v) { *(unsigned int *)(__hxcpp_memory+addr) = v; }
inline void __hxcpp_memory_set_f32(int addr,float v) { __hxcpp_align_set_float32(__hxcpp_memory,addr,v); }
// FPHelper conversion
inline void __hxcpp_reverse_endian(int &ioData)
{
ioData = (((ioData>>24) & 0xff ) )|
(((ioData>>16) & 0xff )<<8 )|
(((ioData>>8 ) & 0xff )<<16 )|
(((ioData ) & 0xff )<<24 );
}
inline float __hxcpp_reinterpret_le_int32_as_float32(int inInt)
{
#ifdef HXCPP_BIG_ENDIAN
__hxcpp_reverse_endian(inInt);
#endif
return *(float*)(&inInt);
}
inline int __hxcpp_reinterpret_float32_as_le_int32(float inFloat)
{
#ifdef HXCPP_BIG_ENDIAN
__hxcpp_reverse_endian(*(int *)&inFloat);
#endif
return *(int*)(&inFloat);
}
inline double __hxcpp_reinterpret_le_int32s_as_float64(int inLow, int inHigh)
{
int vals[2] = {inLow, inHigh};
#ifdef HXCPP_BIG_ENDIAN
__hxcpp_reverse_endian(vals[0]);
__hxcpp_reverse_endian(vals[1]);
#endif
return *(double*)(vals);
}
inline int __hxcpp_reinterpret_float64_as_le_int32_low(double inValue)
{
int *asInts = (int *)&inValue;
#ifdef HXCPP_BIG_ENDIAN
__hxcpp_reverse_endian(asInts[0]);
#endif
return asInts[0];
}
inline int __hxcpp_reinterpret_float64_as_le_int32_high(double inValue)
{
int *asInts = (int *)&inValue;
#ifdef HXCPP_BIG_ENDIAN
__hxcpp_reverse_endian(asInts[1]);
#endif
return asInts[1];
}
#ifdef __OBJC__
#ifdef HXCPP_OBJC
inline NSData *_hx_bytes_to_nsdata( ::Array<unsigned char> inBytes)
{
if (!inBytes.mPtr)
return nil;
return [NSData dataWithBytes: inBytes->getBase() length:inBytes->length ];
}
inline ::Array<unsigned char> _hx_nsdata_to_bytes(NSData *inData)
{
if (inData==nil)
return null();
return ::Array_obj<unsigned char>::fromData( (const unsigned char *)inData.bytes, inData.length );
}
#endif
#endif
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
// EReg.hx -> src/hx/libs/regexp/RegExp.cpp
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_new_options(String s, String options);
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_regexp_match(Dynamic handle, String string, int pos, int len);
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_regexp_matched(Dynamic handle, int pos);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_regexp_matched_pos(Dynamic handle, int match);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_regexp_matched_num(Dynamic handle);
// haxe.zip.(Un)Compress.hx -> src/hx/libs/zlib/ZLib.cpp
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_init(int level);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_deflate_bound(Dynamic handle,int length);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_deflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_deflate_end(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_init(Dynamic windowBits);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_inflate_buffer(Dynamic handle, Array<unsigned char> src, int srcPos, Array<unsigned char> dest, int destPos);
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_inflate_end(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_zip_set_flush_mode(Dynamic handle, String flushMode);
// sys.db.Mysql.hx -> src/hx/libs/regexp/RegExp.cpp
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_connect(Dynamic params);
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_mysql_select_db(Dynamic handle,String db);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_request(Dynamic handle,String req);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_close(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_mysql_escape(Dynamic handle,String str);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_length(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_nfields(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_mysql_result_next(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_mysql_result_get(Dynamic handle,int i);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_mysql_result_get_int(Dynamic handle,int i);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float _hx_mysql_result_get_float(Dynamic handle,int i);
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_mysql_result_get_fields_names(Dynamic handle);
namespace cpp { template<typename T> class Function; }
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_mysql_set_conversion(
cpp::Function< Dynamic(Dynamic) > inCharsToBytes,
cpp::Function< Dynamic(Float) > inTimeToDate );
// sys.db.Sqlite.hx -> src/hx/libs/sqlite/RegExp.cpp
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_connect(String filename);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_request(Dynamic handle,String req);
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_sqlite_close(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_last_insert_id(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_length(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_nfields(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_sqlite_result_next(Dynamic handle);
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_sqlite_result_get(Dynamic handle,int i);
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_sqlite_result_get_int(Dynamic handle,int i);
HXCPP_EXTERN_CLASS_ATTRIBUTES Float _hx_sqlite_result_get_float(Dynamic handle,int i);
// src/hx/libs/std ..
// File
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_open( String fname, String r );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_close( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_write( Dynamic handle, Array<unsigned char> s, int p, int n );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_write_char( Dynamic handle, int c );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read( Dynamic handle, Array<unsigned char> buf, int p, int n );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_read_char( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_seek( Dynamic handle, int pos, int kind );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_file_tell( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_file_eof( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_flush( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_contents_string( String name );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_file_contents_bytes( String name );
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdin();
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stdout();
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_file_stderr();
// Process
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_run( String cmd, Array<String> vargs, int inShow= 1 /* SHOW_NORMAL */ );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdout_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stderr_read( Dynamic handle, Array<unsigned char> buf, int pos, int len );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_stdin_write( Dynamic handle, Array<unsigned char> buf, int pos, int len );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_stdin_close( Dynamic handle );
#if (HXCPP_API_LEVEL > 420)
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_process_exit( Dynamic handle, bool block );
#else
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_exit( Dynamic handle );
#endif
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_process_pid( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_kill( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_process_close( Dynamic handle );
// Random
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_random_new();
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_random_set_seed( Dynamic handle, int v );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_random_int( Dynamic handle, int max );
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_random_float( Dynamic handle );
// Socket
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_init();
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_new( bool udp, bool ipv6 = false );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind( Dynamic o, int host, int port );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_bind_ipv6( Dynamic o, Array<unsigned char> host, int port );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_close( Dynamic handle );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_send_char( Dynamic o, int c );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send( Dynamic o, Array<unsigned char> buf, int p, int l );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv( Dynamic o, Array<unsigned char> buf, int p, int l );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_char( Dynamic o );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_write( Dynamic o, Array<unsigned char> buf );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_socket_read( Dynamic o );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_host_resolve( String host );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<unsigned char> _hx_std_host_resolve_ipv6( String host, bool dummy=true );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string( int ip );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_to_string_ipv6( Array<unsigned char> ip );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse( int host );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_reverse_ipv6( Array<unsigned char> host );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_host_local();
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect( Dynamic o, int host, int port );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_connect_ipv6( Dynamic o, Array<unsigned char> host, int port );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_listen( Dynamic o, int n );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_fast_select( Array<Dynamic> rs, Array<Dynamic> ws, Array<Dynamic> es, Dynamic timeout );
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_accept( Dynamic o );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_peer( Dynamic o );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<int> _hx_std_socket_host( Dynamic o );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_timeout( Dynamic o, Dynamic t );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_shutdown( Dynamic o, bool r, bool w );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_blocking( Dynamic o, bool b );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_fast_send( Dynamic o, bool b );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_set_broadcast( Dynamic o, bool b );
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_socket_poll_alloc( int nsocks );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll_prepare( Dynamic pdata, Array<Dynamic> rsocks, Array<Dynamic> wsocks );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_socket_poll_events( Dynamic pdata, double timeout );
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<Dynamic> _hx_std_socket_poll( Array<Dynamic> socks, Dynamic pdata, double timeout );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_send_to( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic inAddr );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_socket_recv_from( Dynamic o, Array<unsigned char> buf, int p, int l, Dynamic outAddr);
// Sys
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_env( String v );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_put_env( String e, String v );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_sleep( double f );
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_time_locale( String l );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_get_cwd();
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_set_cwd( String d );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_string();
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_is64();
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_command( String cmd );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_exit( int code );
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_exists( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_file_delete( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_rename( String path, String newname );
HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic _hx_std_sys_stat( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_file_type( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES bool _hx_std_sys_create_dir( String path, int mode );
HXCPP_EXTERN_CLASS_ATTRIBUTES void _hx_std_sys_remove_dir( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_time();
HXCPP_EXTERN_CLASS_ATTRIBUTES double _hx_std_sys_cpu_time();
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_read_dir( String p);
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_file_full_path( String path );
HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_std_sys_exe_path();
HXCPP_EXTERN_CLASS_ATTRIBUTES Array<String> _hx_std_sys_env();
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_getch( bool b );
HXCPP_EXTERN_CLASS_ATTRIBUTES int _hx_std_sys_get_pid();
// SSL
void _hx_ssl_init();
Dynamic _hx_ssl_new( Dynamic hconf );
void _hx_ssl_close( Dynamic hssl );
void _hx_ssl_debug_set (int i);
void _hx_ssl_handshake( Dynamic handle );
void _hx_ssl_set_socket( Dynamic hssl, Dynamic hsocket );
void _hx_ssl_set_hostname( Dynamic hssl, String hostname );
Dynamic _hx_ssl_get_peer_certificate( Dynamic hssl );
bool _hx_ssl_get_verify_result( Dynamic hssl );
void _hx_ssl_send_char( Dynamic hssl, int v );
int _hx_ssl_send( Dynamic hssl, Array<unsigned char> buf, int p, int l );
void _hx_ssl_write( Dynamic hssl, Array<unsigned char> buf );
int _hx_ssl_recv_char( Dynamic hssl );
int _hx_ssl_recv( Dynamic hssl, Array<unsigned char> buf, int p, int l );
Array<unsigned char> _hx_ssl_read( Dynamic hssl );
Dynamic _hx_ssl_conf_new( bool server );
void _hx_ssl_conf_close( Dynamic hconf );
void _hx_ssl_conf_set_ca( Dynamic hconf, Dynamic hcert );
void _hx_ssl_conf_set_verify( Dynamic hconf, int mode );
void _hx_ssl_conf_set_cert( Dynamic hconf, Dynamic hcert, Dynamic hpkey );
void _hx_ssl_conf_set_servername_callback( Dynamic hconf, Dynamic obj );
Dynamic _hx_ssl_cert_load_defaults();
Dynamic _hx_ssl_cert_load_file( String file );
Dynamic _hx_ssl_cert_load_path( String path );
String _hx_ssl_cert_get_subject( Dynamic hcert, String objname );
String _hx_ssl_cert_get_issuer( Dynamic hcert, String objname );
Array<String> _hx_ssl_cert_get_altnames( Dynamic hcert );
Array<int> _hx_ssl_cert_get_notbefore( Dynamic hcert );
Array<int> _hx_ssl_cert_get_notafter( Dynamic hcert );
Dynamic _hx_ssl_cert_get_next( Dynamic hcert );
Dynamic _hx_ssl_cert_add_pem( Dynamic hcert, String data );
Dynamic _hx_ssl_cert_add_der( Dynamic hcert, Array<unsigned char> buf );
Dynamic _hx_ssl_key_from_der( Array<unsigned char> buf, bool pub );
Dynamic _hx_ssl_key_from_pem( String data, bool pub, String pass );
Array<unsigned char> _hx_ssl_dgst_make( Array<unsigned char> buf, String alg );
Array<unsigned char> _hx_ssl_dgst_sign( Array<unsigned char> buf, Dynamic hpkey, String alg );
bool _hx_ssl_dgst_verify( Array<unsigned char> buf, Array<unsigned char> sign, Dynamic hpkey, String alg );
#endif

30
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StdString.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef HX_STD_STRING_INCLUDEDED
#define HX_STD_STRING_INCLUDEDED
#include <string>
namespace hx
{
class StdString : public std::string
{
public:
StdString() : std::string() { }
StdString(const char *inPtr) : std::string(inPtr) { }
StdString(const char *inPtr, int inLen) : std::string(inPtr, inLen) { }
StdString(const std::string &inS) : std::string(inS) { }
StdString(const StdString &inS) : std::string(inS) { }
#if (HXCPP_API_LEVEL>1)
StdString(const Dynamic &inS) : std::string(inS.mPtr ? inS.mPtr->toString().utf8_str() : "null") { }
StdString(const String &inS) : std::string(inS.utf8_str()) { }
String toString() const { return String(c_str(),size()).dup(); }
String toString() { return String(c_str(),size()).dup(); }
operator Dynamic() const { return const_cast<StdString*>(this)->toString(); }
#endif
inline const StdString &toStdString() const { return *this; }
};
}
#endif

53
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/StringAlloc.h Executable file
View File

@ -0,0 +1,53 @@
#ifndef HX_STRING_ALLOC
#define HX_STRING_ALLOC
#include <stdlib.h>
#include <stdint.h>
namespace hx
{
class IStringAlloc
{
public:
virtual void *allocBytes(size_t inBytes) = 0;
protected:
~IStringAlloc(){};
};
template<int STACK>
class StringAlloc : public IStringAlloc
{
char buffer[STACK];
size_t alloced;
char *heap;
public:
inline StringAlloc() : alloced(0), heap(0) { }
~StringAlloc()
{
if (heap)
free(heap);
}
void *allocBytes(size_t inBytes)
{
if (inBytes<=STACK)
return buffer;
if (inBytes>alloced)
{
alloced = inBytes;
heap = (char *)realloc(heap, alloced);
}
return heap;
}
private:
StringAlloc(const StringAlloc &);
void operator=(const StringAlloc &);
};
typedef StringAlloc<100> strbuf;
} // end namespace hx
#endif

35
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Telemetry.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef HX_TELEMETRY_H
#define HX_TELEMETRY_H
#define HX_TELEMETRY_VERSION 1
#include <hxcpp.h>
#include <vector>
struct TelemetryFrame
{
// microseconds, always valid
int gctime;
int gcoverhead;
// Valid only if profiler is enabled
std::vector<int> *samples;
std::vector<const char*> *names;
// Valid only if allocations (and profiler) are enabled
std::vector<int> *allocation_data;
std::vector<int> *stacks;
};
// --- Telemetry -----------------------------------------------------------------
int __hxcpp_hxt_start_telemetry(bool profiler, bool allocations);
void __hxcpp_hxt_stash_telemetry();
TelemetryFrame* __hxcpp_hxt_dump_telemetry(int thread_num);
void __hxcpp_hxt_ignore_allocs(int delta);
// expose these from GCInternal
int __hxcpp_gc_reserved_bytes();
int __hxcpp_gc_used_bytes();
#endif

458
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Thread.h Normal file
View File

@ -0,0 +1,458 @@
#ifdef HX_THREAD_H_OVERRIDE
// Users can define their own header to use here, but there is no API
// compatibility gaurantee for future changes.
#include HX_THREAD_H_OVERRIDE
#else
#ifndef HX_THREAD_H
#define HX_THREAD_H
#ifndef HXCPP_HEADER_VERSION
#include "hx/HeaderVersion.h"
#endif
#if defined(KORE)
#include <kinc/threads/atomic.h>
#include <kinc/threads/event.h>
#include <kinc/threads/mutex.h>
#include <kinc/threads/thread.h>
#elif defined(HX_WINRT)
#include <windows.h>
#include <process.h>
#include <mutex>
#elif defined(_WIN32)
#ifdef HXCPP_WINXP_COMPAT
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0400
#else
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
#include <windows.h>
#include <process.h>
#else
#include <errno.h>
#include <pthread.h>
#include <sys/time.h>
#include <stdio.h>
#define HXCPP_PTHREADS
#endif
#ifdef RegisterClass
#undef RegisterClass
#endif
#if defined(KORE)
struct HxMutex {
HxMutex() {
kinc_mutex_init(&mutex);
}
~HxMutex() {
kinc_mutex_destroy(&mutex);
}
void Lock() {
kinc_mutex_lock(&mutex);
}
void Unlock() {
kinc_mutex_unlock(&mutex);
}
bool TryLock() {
return kinc_mutex_try_to_lock(&mutex);
}
void Clean() {
kinc_mutex_destroy(&mutex);
}
private:
kinc_mutex_t mutex;
};
#define THREAD_FUNC_TYPE void
#define THREAD_FUNC_RET return;
inline bool HxCreateDetachedThread(void (*func)(void *), void *param)
{
kinc_thread_t thread;
kinc_thread_init(&thread, func, param);
return true;
}
#elif defined(HX_WINDOWS)
struct HxMutex
{
HxMutex()
{
mValid = true;
#ifdef HX_WINRT
InitializeCriticalSectionEx(&mCritSec,4000,0);
#else
InitializeCriticalSection(&mCritSec);
#endif
}
~HxMutex() { if (mValid) DeleteCriticalSection(&mCritSec); }
void Lock() { EnterCriticalSection(&mCritSec); }
void Unlock() { LeaveCriticalSection(&mCritSec); }
bool TryLock() { return TryEnterCriticalSection(&mCritSec); }
bool IsValid() { return mValid; }
void Clean()
{
if (mValid)
{
DeleteCriticalSection(&mCritSec);
mValid = false;
}
}
bool mValid;
CRITICAL_SECTION mCritSec;
};
#define THREAD_FUNC_TYPE DWORD WINAPI
#define THREAD_FUNC_RET return 0;
inline bool HxCreateDetachedThread(DWORD (WINAPI *func)(void *), void *param)
{
return (CreateThread(NULL, 0, func, param, 0, 0) != 0);
}
#else
struct HxMutex
{
HxMutex()
{
pthread_mutexattr_t mta;
pthread_mutexattr_init(&mta);
pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
mValid = pthread_mutex_init(&mMutex,&mta) ==0;
}
~HxMutex() { if (mValid) pthread_mutex_destroy(&mMutex); }
void Lock() { pthread_mutex_lock(&mMutex); }
void Unlock() { pthread_mutex_unlock(&mMutex); }
bool TryLock() { return !pthread_mutex_trylock(&mMutex); }
bool IsValid() { return mValid; }
void Clean()
{
if (mValid)
pthread_mutex_destroy(&mMutex);
mValid = 0;
}
bool mValid;
pthread_mutex_t mMutex;
};
#define THREAD_FUNC_TYPE void *
#define THREAD_FUNC_RET return 0;
inline bool HxCreateDetachedThread(void *(*func)(void *), void *param)
{
pthread_t t;
pthread_attr_t attr;
if (pthread_attr_init(&attr) != 0)
return false;
#ifdef PTHREAD_CREATE_DETACHED
if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
return false;
#endif
if (pthread_create(&t, &attr, func, param) != 0 )
return false;
if (pthread_attr_destroy(&attr) != 0)
return false;
return true;
}
#endif
template<typename LOCKABLE>
struct TAutoLock
{
TAutoLock(LOCKABLE &inMutex) : mMutex(inMutex) { mMutex.Lock(); }
~TAutoLock() { mMutex.Unlock(); }
void Lock() { mMutex.Lock(); }
void Unlock() { mMutex.Unlock(); }
LOCKABLE &mMutex;
};
typedef TAutoLock<HxMutex> AutoLock;
#if defined(KORE)
struct HxSemaphore {
HxSemaphore() {
kinc_event_init(&event, true);
}
~HxSemaphore() {
kinc_event_destroy(&event);
}
void Set() {
kinc_event_signal(&event);
}
void Wait() {
kinc_event_wait(&event);
}
bool WaitSeconds(double inSeconds) {
return kinc_event_try_to_wait(&event, inSeconds);
}
void Reset() {
kinc_event_reset(&event);
}
void Clean() {
kinc_event_destroy(&event);
}
private:
kinc_event_t event;
};
struct ThreadPoolSignal {
ThreadPoolSignal() {
kinc_event_init(&event, true);
}
~ThreadPoolSignal() {
}
void Set() {
kinc_event_signal(&event);
}
void Wait() {
kinc_event_wait(&event);
}
bool WaitSeconds(double inSeconds) {
return kinc_event_try_to_wait(&event, inSeconds);
}
void Reset() {
kinc_event_reset(&event);
}
void Clean() {
kinc_event_destroy(&event);
}
private:
kinc_event_t event;
};
#elif defined(HX_WINDOWS)
struct HxSemaphore
{
HxSemaphore()
{
#ifdef HX_WINRT
mSemaphore = CreateEventEx(nullptr,nullptr,0,EVENT_ALL_ACCESS);
#else
mSemaphore = CreateEvent(0,0,0,0);
#endif
}
~HxSemaphore() { if (mSemaphore) CloseHandle(mSemaphore); }
void Set() { SetEvent(mSemaphore); }
void Wait()
{
#ifdef HX_WINRT
WaitForSingleObjectEx(mSemaphore,INFINITE,false);
#else
WaitForSingleObject(mSemaphore,INFINITE);
#endif
}
// Returns true on success, false on timeout
bool WaitSeconds(double inSeconds)
{
#ifdef HX_WINRT
return WaitForSingleObjectEx(mSemaphore,inSeconds*1000.0,false) != WAIT_TIMEOUT;
#else
return WaitForSingleObject(mSemaphore,inSeconds*1000.0) != WAIT_TIMEOUT;
#endif
}
void Reset() { ResetEvent(mSemaphore); }
void Clean() { if (mSemaphore) CloseHandle(mSemaphore); mSemaphore = 0; }
HANDLE mSemaphore;
};
#else
#define HX_THREAD_SEMAPHORE_LOCKABLE
struct HxSemaphore
{
HxSemaphore()
{
mSet = false;
mValid = true;
pthread_cond_init(&mCondition,0);
}
~HxSemaphore()
{
if (mValid)
{
pthread_cond_destroy(&mCondition);
}
}
// For autolock
inline operator HxMutex &() { return mMutex; }
void Set()
{
AutoLock lock(mMutex);
if (!mSet)
{
mSet = true;
pthread_cond_signal( &mCondition );
}
}
void QSet()
{
mSet = true;
pthread_cond_signal( &mCondition );
}
void Reset()
{
AutoLock lock(mMutex);
mSet = false;
}
void QReset() { mSet = false; }
void Wait()
{
AutoLock lock(mMutex);
while( !mSet )
pthread_cond_wait( &mCondition, &mMutex.mMutex );
mSet = false;
}
// when we already hold the mMutex lock ...
void QWait()
{
while( !mSet )
pthread_cond_wait( &mCondition, &mMutex.mMutex );
mSet = false;
}
// Returns true if the wait was success, false on timeout.
bool WaitSeconds(double inSeconds)
{
struct timeval tv;
gettimeofday(&tv, 0);
int isec = (int)inSeconds;
int usec = (int)((inSeconds-isec)*1000000.0);
timespec spec;
spec.tv_nsec = (tv.tv_usec + usec) * 1000;
if (spec.tv_nsec>1000000000)
{
spec.tv_nsec-=1000000000;
isec++;
}
spec.tv_sec = tv.tv_sec + isec;
AutoLock lock(mMutex);
int result = 0;
// Wait for set to be true...
while( !mSet && (result=pthread_cond_timedwait( &mCondition, &mMutex.mMutex, &spec )) != ETIMEDOUT)
{
if (result!=0)
{
// Error - something's gone wrong...
/*
if (result==EINVAL)
printf("ERROR: Condition EINVAL\n");
else if (result==EPERM)
printf("ERROR: Condition EPERM\n");
else
printf("ERROR: Condition unknown error\n");
*/
break;
}
// Condition signalled - but try mSet again ...
}
bool wasSet = mSet;
mSet = false;
return wasSet;
}
void Clean()
{
mMutex.Clean();
if (mValid)
{
mValid = false;
pthread_cond_destroy(&mCondition);
}
}
HxMutex mMutex;
pthread_cond_t mCondition;
bool mSet;
bool mValid;
};
#endif
#if defined(KORE)
#include <kinc/threads/thread.h>
inline void HxSleep(unsigned int ms)
{
kinc_thread_sleep(ms);
}
#elif defined HX_WINRT
inline void HxSleep(unsigned int ms)
{
::Sleep(ms);
}
#elif defined HX_WINDOWS
inline void HxSleep(unsigned int ms)
{
::Sleep(ms);
}
#else
inline void HxSleep(unsigned int ms)
{
struct timespec t;
struct timespec tmp;
t.tv_sec = 0;
t.tv_nsec = ms * 1000000;
nanosleep(&t, &tmp);
}
#endif
#endif
#endif

200
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Tls.h Executable file
View File

@ -0,0 +1,200 @@
#ifdef HX_TLS_H_OVERRIDE
// Users can define their own header to use here, but there is no API
// compatibility gaurantee for future changes.
#include HX_TLS_H_OVERRIDE
#else
#ifndef HX_TLS_INCLUDED
#define HX_TLS_INCLUDED
#if defined(HX_WINDOWS) || defined(KORE_CONSOLE)
#if defined(HX_WINRT)
// Nothing
#elif defined(KORE_CONSOLE)
#include <kinc/threads/threadlocal.h>
namespace hx {
template<typename DATA, bool FAST = false> struct TLSData {
TLSData() {
kinc_thread_local_init(&tls);
}
~TLSData() {
kinc_thread_local_destroy(&tls);
}
DATA *Get() {
return (DATA*)kinc_thread_local_get(&tls);
}
void Set(DATA *inData) {
kinc_thread_local_set(&tls, inData);
}
inline DATA *operator=(DATA *inData) {
kinc_thread_local_set(&tls, inData);
return inData;
}
inline operator DATA*() {
return (DATA*)kinc_thread_local_get(&tls);
}
private:
kinc_thread_local_t tls;
};
}
#else
#if ! defined(__GNUC__) && !defined(__BORLANDC__)
#include <intrin.h>
#endif
extern "C"
{
__declspec(dllimport)
int __stdcall TlsSetValue(unsigned long dwTlsIndex, void *lpTlsValue);
__declspec(dllimport)
void * __stdcall TlsGetValue(unsigned long dwTlsIndex);
__declspec(dllimport)
unsigned long __stdcall TlsAlloc(void);
}
namespace hx {
template<typename DATA,bool FAST=false>
struct TLSData
{
static const size_t kMaxInlineSlots = 64;
TLSData()
{
mSlot = TlsAlloc();
TlsSetValue(mSlot,0);
#ifdef HXCPP_M64
mFastOffset = mSlot*sizeof(void *) + 0x1480;
#else
if (FAST || mSlot < kMaxInlineSlots)
mFastOffset = mSlot*sizeof(void *) + 0xE10;
else
mFastOffset = mSlot - kMaxInlineSlots;
#endif
}
inline DATA *operator=(DATA *inData)
{
TlsSetValue(mSlot,inData);
return inData;
}
inline operator DATA *()
{
#if !defined(HXCPP_M64) && (_MSC_VER >= 1400)
const size_t kTibExtraTlsOffset = 0xF94;
if (FAST || mSlot < kMaxInlineSlots)
return (DATA *)__readfsdword(mFastOffset);
DATA **extra = (DATA **)(__readfsdword(kTibExtraTlsOffset));
return extra[mFastOffset];
#elif (_MSC_VER >= 1400) & !defined(HXCPP_DEBUG) && !defined(HXCPP_ARM64)// 64 bit version...
if (mSlot < 64)
return (DATA *)__readgsqword(mFastOffset);
else
return (DATA *)TlsGetValue(mSlot);
#else
return (DATA *)TlsGetValue(mSlot);
#endif
}
int mSlot;
int mFastOffset;
};
} // end namespace hx
#define DECLARE_TLS_DATA(TYPE,NAME) \
hx::TLSData<TYPE> NAME;
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
hx::TLSData<TYPE,true> NAME;
#define EXTERN_TLS_DATA(TYPE,NAME) \
extern hx::TLSData<TYPE> NAME;
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
extern hx::TLSData<TYPE,true> NAME;
#endif
#else // not HX_WINDOWS
#include <pthread.h>
namespace hx
{
template<typename DATA,bool FAST=false>
struct TLSData
{
TLSData()
{
pthread_key_create(&mSlot, 0);
}
DATA *Get()
{
return (DATA *)pthread_getspecific(mSlot);
}
void Set(DATA *inData)
{
pthread_setspecific(mSlot,inData);
}
inline DATA *operator=(DATA *inData)
{
pthread_setspecific(mSlot,inData);
return inData;
}
inline operator DATA *() { return (DATA *)pthread_getspecific(mSlot); }
pthread_key_t mSlot;
};
} // end namespace hx
#endif
#ifdef HX_WINRT
#define DECLARE_TLS_DATA(TYPE,NAME) \
__declspec(thread) TYPE * NAME = nullptr;
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
__declspec(thread) TYPE * NAME = nullptr;
#define EXTERN_TLS_DATA(TYPE,NAME) \
__declspec(thread) extern TYPE * NAME;
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
__declspec(thread) extern TYPE * NAME;
#else
#define DECLARE_TLS_DATA(TYPE,NAME) \
hx::TLSData<TYPE> NAME;
#define DECLARE_FAST_TLS_DATA(TYPE,NAME) \
hx::TLSData<TYPE,true> NAME;
#define EXTERN_TLS_DATA(TYPE,NAME) \
extern hx::TLSData<TYPE> NAME;
#define EXTERN_FAST_TLS_DATA(TYPE,NAME) \
extern hx::TLSData<TYPE,true> NAME;
#endif
#endif
#endif

44
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Undefine.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef HX_UNDEFINE_H
#define HX_UNDEFINE_H
#if (HXCPP_API_LEVEL < 321)
#undef INT_MIN
#undef INT_MAX
#undef INT8_MIN
#undef INT8_MAX
#undef UINT8_MAX
#undef INT16_MIN
#undef INT16_MAX
#undef UINT16_MAX
#undef INT32_MIN
#undef INT32_MAX
#undef UINT32_MAX
#endif
#undef TRUE
#undef FALSE
#undef BOOLEAN
#undef ERROR
#undef NO_ERROR
#undef DELETE
#undef OPTIONS
#undef IN
#undef OUT
#undef ALTERNATE
#undef OPTIONAL
#undef DOUBLE_CLICK
#undef DIFFERENCE
#undef POINT
#undef RECT
#undef OVERFLOW
#undef UNDERFLOW
#undef DOMAIN
#undef TRANSPARENT
#undef CONST
#undef CopyFile
#undef COLOR_HIGHLIGHT
#undef __valid
#endif

38
Kha/Backends/Kinc-hxcpp/khacpp/include/hx/Unordered.h Normal file
View File

@ -0,0 +1,38 @@
#ifndef HX_UNORDERED_INCLUDED
#define HX_UNORDERED_INCLUDED
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || ( defined(__GNUC__) && defined(HXCPP_CPP11) )
#include <unordered_set>
#include <unordered_map>
namespace hx
{
template<typename T>
struct UnorderedSet : public std::unordered_set<T> { };
template<typename KEY, typename VALUE>
struct UnorderedMap : public std::unordered_map<KEY,VALUE> { };
}
#else
#include <set>
#include <map>
namespace hx
{
template<typename T>
struct UnorderedSet : public std::set<T> { };
template<typename KEY, typename VALUE>
struct UnorderedMap : public std::map<KEY,VALUE> { };
}
#endif
#endif

84
Kha/Backends/Kinc-hxcpp/khacpp/include/hxMath.h Normal file
View File

@ -0,0 +1,84 @@
#ifndef HX_MATH
#define HX_MATH
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#include <cmath>
#include <stdlib.h>
class HXCPP_EXTERN_CLASS_ATTRIBUTES Math_obj : public hx::Object
{
public:
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdMath };
typedef hx::Object super;
typedef Math_obj OBJ_;
HX_DO_RTTI;
void __construct();
static Dynamic __CreateEmpty();
static void __boot();
inline static int floor(double inX) { return __int__(::std::floor(inX)); }
inline static int ceil(double inX) { return __int__(::std::ceil(inX)); }
inline static int round(double inX) { return floor(inX+0.5); }
inline static double ffloor(double inX) { return ::std::floor(inX); }
inline static double fceil(double inX) { return ::std::ceil(inX); }
inline static double fround(double inX) { return ::std::floor(inX+0.5); }
inline static double random() { return __hxcpp_drand(); }
inline static double sqrt(double inX) { return ::std::sqrt(inX); }
inline static double cos(double inX) { return ::std::cos(inX); }
inline static double sin(double inX) { return ::std::sin(inX); }
inline static double tan(double inX) { return ::std::tan(inX); }
inline static double atan2(double inY,double inX) { return ::std::atan2(inY,inX); }
inline static double abs(double inX) { return ::std::fabs(inX); }
inline static double pow(double inA,double inB) { return ::std::pow(inA,inB); }
inline static double log(double inA) { return ::std::log(inA); }
inline static double max(double inA,double inB) { return inA>inB ? inA:inA==inA?inB:inA; }
inline static double min(double inA,double inB) { return inA<inB ? inA:inA==inA?inB:inA; }
inline static double atan(double inA) { return ::std::atan(inA); }
inline static double asin(double inA) { return ::std::asin(inA); }
inline static double acos(double inA) { return ::std::acos(inA); }
inline static double exp(double inA) { return ::std::exp(inA); }
static bool isNaN(double inX);
static bool isFinite(double inX);
static Dynamic floor_dyn();
static Dynamic ceil_dyn();
static Dynamic round_dyn();
static Dynamic ffloor_dyn();
static Dynamic fceil_dyn();
static Dynamic fround_dyn();
static Dynamic random_dyn();
static Dynamic sqrt_dyn();
static Dynamic cos_dyn();
static Dynamic sin_dyn();
static Dynamic tan_dyn();
static Dynamic atan2_dyn();
static Dynamic abs_dyn();
static Dynamic pow_dyn();
static Dynamic log_dyn();
static Dynamic min_dyn();
static Dynamic max_dyn();
static Dynamic atan_dyn();
static Dynamic asin_dyn();
static Dynamic acos_dyn();
static Dynamic exp_dyn();
static Dynamic isNaN_dyn();
static Dynamic isFinite_dyn();
static double NaN;
static double PI;
static double NEGATIVE_INFINITY;
static double POSITIVE_INFINITY;
};
typedef hx::ObjectPtr<Math_obj> Math;
#endif

406
Kha/Backends/Kinc-hxcpp/khacpp/include/hxString.h Normal file
View File

@ -0,0 +1,406 @@
#ifndef HX_STRING_H
#define HX_STRING_H
#ifndef HXCPP_H
#error "Please include hxcpp.h, not hx/Object.h"
#endif
#include <hx/StringAlloc.h>
#ifdef __OBJC__
#import <Foundation/Foundation.h>
#endif
#if __cplusplus < 201103L && !defined(KORE_MICROSOFT)
typedef unsigned short char16_t;
#endif
// --- String --------------------------------------------------------
//
// Basic String type for hxcpp.
// It's based on garbage collection of the wchar_t (or char ) *ptr.
// Note: this does not inherit from "hx::Object", so in some ways it acts more
// like a standard "int" type than a mode generic class.
class HXCPP_EXTERN_CLASS_ATTRIBUTES String
{
friend class StringOffset;
public:
// These allocate the function using the garbage-colleced malloc
void *operator new( size_t inSize );
inline void* operator new( size_t, void* ptr ) { return ptr; }
void operator delete( void * ) { }
inline String() : length(0), __s(0) { }
// Uses pointer
inline String(const char *inPtr,int inLen) : __s(inPtr), length(inLen) { }
#ifdef HX_SMART_STRINGS
inline String(const char16_t *inPtr,int inLen) : __w(inPtr), length(inLen) { }
#endif
// Makes copy
inline String(const wchar_t *inPtr) { *this = create(inPtr); }
inline String(const char16_t *inPtr) { *this = create(inPtr); }
inline String(const char *inPtr) { *this = create(inPtr); }
static String create(const wchar_t *inPtr,int inLen=-1);
static String create(const char16_t *inPtr,int inLen=-1);
static String create(const char *inPtr,int inLen=-1);
// Uses non-gc memory and wont ever be collected
static ::String createPermanent(const char *inUtf8, int inLen);
const ::String &makePermanent() const;
hx::Object *makePermanentObject() const;
// Legacy
::String &dup();
#ifdef __OBJC__
inline String(NSString *inString)
{
if (inString)
*this = String([inString UTF8String]);
else
{
length = 0;
__s = 0;
}
}
inline operator NSString * () const
{
hx::strbuf buf;
return [[NSString alloc] initWithUTF8String:utf8_str(&buf) ];
}
#endif
#if defined(HX_WINRT) && defined(__cplusplus_winrt)
inline String(Platform::String^ inString)
{
*this = String(inString->Data());
}
inline String(Platform::StringReference inString)
{
*this = String(inString.Data());
}
#endif
inline String(const ::String &inRHS) : __s(inRHS.__s), length(inRHS.length) { }
String(const int &inRHS);
String(const unsigned int &inRHS);
String(const short &inRHS) { fromInt(inRHS); }
String(const unsigned short &inRHS) { fromInt(inRHS); }
String(const signed char &inRHS) { fromInt(inRHS); }
String(const unsigned char &inRHS) { fromInt(inRHS); }
String(const cpp::CppInt32__ &inRHS);
String(const double &inRHS);
String(const float &inRHS);
String(const cpp::Int64 &inRHS);
String(const cpp::UInt64 &inRHS);
explicit String(const bool &inRHS);
inline String(const null &inRHS) : __s(0), length(0) { }
String(hx::Null< ::String > inRHS) : __s(inRHS.value.__s), length(inRHS.value.length) { }
inline String(const ::cpp::Variant &inRHS) { *this = inRHS.asString(); }
template<typename T>
inline String( const ::cpp::Pointer<T> &inRHS) { fromPointer(inRHS.ptr); }
template<typename T>
inline String( const hx::Native<T> &n ) { fromPointer(n.ptr); }
static String emptyString;
static void __boot();
hx::Object *__ToObject() const;
template<typename T,typename S>
explicit inline String(const cpp::Struct<T,S> &inRHS);
template<typename OBJ>
explicit inline String(const hx::ObjectPtr<OBJ> &inRHS);
void fromInt(int inI);
void fromPointer(const void *p);
/*
This causes ambiguous problem with Object==Dynamic (String==Dynamic vs Object==Object)
and syntactically, String(Dynamic) should be enough I think.
Could perhaps make it explicit
template<typename T>
inline String(const hx::ObjectPtr<T> &inRHS)
{
if (inRHS.mPtr)
{
::String s = static_cast<hx::Object *>(inRHS.mPtr)->toString();
__s = s.__s;
length = s.length;
}
else { __s = 0; length = 0; }
}
*/
String(const Dynamic &inRHS);
inline ::String &operator=(const ::String &inRHS)
{ length = inRHS.length; __s = inRHS.__s; return *this; }
::String Default(const ::String &inDef) { return __s ? *this : inDef; }
::String toString() { return *this; }
::String __URLEncode() const;
::String __URLDecode() const;
::String toUpperCase() const;
::String toLowerCase() const;
::String charAt(int inPos) const;
Dynamic charCodeAt(int inPos) const;
int indexOf(const ::String &inValue, Dynamic inStart) const;
int lastIndexOf(const ::String &inValue, Dynamic inStart) const;
Array<String> split(const ::String &inDelimiter) const;
::String substr(int inPos,Dynamic inLen) const;
::String substring(int inStartIndex, Dynamic inEndIndex) const;
inline const char *&raw_ref() { return __s; }
inline const char *raw_ptr() const { return __s; }
const char *utf8_str(hx::IStringAlloc *inBuffer = 0,bool throwInvalid=true, int *byteLength = 0) const;
const char *ascii_substr(hx::IStringAlloc *inBuffer,int start, int length) const;
inline const char *c_str() const { return utf8_str(); }
inline const char *out_str(hx::IStringAlloc *inBuffer = 0) const { return utf8_str(inBuffer,false); }
const wchar_t *wchar_str(hx::IStringAlloc *inBuffer = 0) const;
const char16_t *wc_str(hx::IStringAlloc *inBuffer = 0, int *outCharLength = 0) const;
const char *__CStr() const { return utf8_str(); };
const wchar_t *__WCStr() const { return wchar_str(0); }
inline operator const char *() { return utf8_str(); }
#ifdef HX_SMART_STRINGS
inline const char16_t *raw_wptr() const { return __w; }
#endif
inline bool isUTF16Encoded() const {
#ifdef HX_SMART_STRINGS
return __w && ((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T;
#else
return false;
#endif
}
inline bool isAsciiEncoded() const {
#ifdef HX_SMART_STRINGS
return !__w || !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
#else
return true;
#endif
}
inline bool isAsciiEncodedQ() const {
#ifdef HX_SMART_STRINGS
return !(((unsigned int *)__w)[-1] & HX_GC_STRING_CHAR16_T);
#else
return true;
#endif
}
static ::String fromCharCode(int inCode);
inline bool operator==(const null &inRHS) const { return __s==0; }
inline bool operator!=(const null &inRHS) const { return __s!=0; }
inline int getChar( int index ) {
if (isUTF16Encoded())
return __w[index];
return __s[index];
}
inline unsigned int hash( ) const
{
if (!__s) return 0;
if ( __s[HX_GC_STRING_HASH_OFFSET] & HX_GC_STRING_HASH_BIT)
{
#ifdef HXCPP_PARANOID
unsigned int result = calcHash();
unsigned int have = (((unsigned int *)__s)[-1] & HX_GC_CONST_ALLOC_BIT) ?
((unsigned int *)__s)[-2] : *((unsigned int *)(__s+length+1) );
if ( have != result )
{
printf("Bad string hash for %s\n", __s );
printf(" Is %08x\n", result );
printf(" Baked %08x\n", have );
printf(" Mark %08x\n", ((unsigned int *)__s)[-1] );
}
#endif
if (__s[HX_GC_CONST_ALLOC_MARK_OFFSET] & HX_GC_CONST_ALLOC_MARK_BIT)
{
#ifdef EMSCRIPTEN
return ((emscripten_align1_int*)__s)[-2];
#else
return ((unsigned int *)__s)[-2];
#endif
}
#ifdef EMSCRIPTEN
return *((emscripten_align1_int *)(__s+length+1) );
#else
return *((unsigned int *)(__s+length+1) );
#endif
}
// Slow path..
return calcHash();
}
unsigned int calcHash() const;
unsigned int calcSubHash(int start, int length) const;
#ifdef HX_SMART_STRINGS
int compare(const ::String &inRHS) const;
#else
inline int compare(const ::String &inRHS) const
{
const char *r = inRHS.__s;
if (__s == r) return inRHS.length-length;
if (__s==0) return -1;
if (r==0) return 1;
return strcmp(__s,r);
//return memcmp(__s,r,length);
}
#endif
::String &operator+=(const ::String &inRHS);
::String operator+(const ::String &inRHS) const;
::String operator+(const int &inRHS) const { return *this + ::String(inRHS); }
::String operator+(const bool &inRHS) const { return *this + ::String(inRHS); }
::String operator+(const double &inRHS) const { return *this + ::String(inRHS); }
::String operator+(const float &inRHS) const { return *this + ::String(inRHS); }
::String operator+(const null &inRHS) const{ return *this + HX_CSTRING("null"); }
//::String operator+(const char *inRHS) const{ return *this + ::String(inRHS); }
::String operator+(const cpp::CppInt32__ &inRHS) const{ return *this + ::String(inRHS); }
template<typename T>
inline ::String operator+(const hx::ObjectPtr<T> &inRHS) const
{ return *this + (inRHS.mPtr ? const_cast<hx::ObjectPtr<T>&>(inRHS)->toString() : HX_CSTRING("null") ); }
::String operator+(const cpp::Variant &inRHS) const{ return *this + inRHS.asString(); }
#ifdef HX_SMART_STRINGS
bool eq(const ::String &inRHS) const;
#else
inline bool eq(const ::String &inRHS) const
{
// Strings are known not to be null...
return length==inRHS.length && !memcmp(__s,inRHS.__s,length);
}
#endif
inline bool operator==(const ::String &inRHS) const
{
if (!inRHS.__s)
return !__s;
if (!__s)
return false;
return eq(inRHS);
}
inline bool operator!=(const ::String &inRHS) const
{
if (!inRHS.__s)
return __s;
if (!__s)
return true;
return !eq(inRHS);
}
inline bool operator<(const ::String &inRHS) const { return compare(inRHS)<0; }
inline bool operator<=(const ::String &inRHS) const { return compare(inRHS)<=0; }
inline bool operator>(const ::String &inRHS) const { return compare(inRHS)>0; }
inline bool operator>=(const ::String &inRHS) const { return compare(inRHS)>=0; }
inline bool operator<(const Dynamic &inRHS) const { return compare(inRHS)<0; }
inline bool operator<=(const Dynamic &inRHS) const { return compare(inRHS)<=0; }
inline bool operator>(const Dynamic &inRHS) const { return compare(inRHS)>0; }
inline bool operator>=(const Dynamic &inRHS) const { return compare(inRHS)>=0; }
inline int cca(int inPos) const
{
if ((unsigned)inPos>=length) return 0;
#ifdef HX_SMART_STRINGS
if (isUTF16Encoded())
return __w[inPos];
#endif
return ((unsigned char *)__s)[inPos];
}
inline Dynamic iterator();
inline Dynamic keyValueIterator();
static char16_t *allocChar16Ptr(int len);
static Dynamic fromCharCode_dyn();
Dynamic charAt_dyn();
Dynamic charCodeAt_dyn();
Dynamic indexOf_dyn();
Dynamic lastIndexOf_dyn();
Dynamic split_dyn();
Dynamic substr_dyn();
Dynamic substring_dyn();
Dynamic toLowerCase_dyn();
Dynamic toString_dyn();
Dynamic toUpperCase_dyn();
// This is used by the string-wrapped-as-dynamic class
hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
// The actual implementation.
// Note that "__s" is const - if you want to change it, you should create a new string.
// this allows for multiple strings to point to the same data.
int length;
#ifdef HX_SMART_STRINGS
// TODO private:
// Use c_str, wc_str, raw_str instead
#endif
union {
const char *__s;
const char16_t *__w;
};
};
class StringOffset
{
public:
enum { Ptr = offsetof(String,__s) };
};
inline HXCPP_EXTERN_CLASS_ATTRIBUTES String _hx_string_create(const char *str, int len)
{
return String::create(str,len);
}
inline int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_string_compare(String inString0, String inString1)
{
return inString0.compare(inString1);
}
String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_to_utf16(const unsigned char *ptr, int inUtf8Len, bool addHash);
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_char_code_at(String inString, int inIndex);
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_length(String inString);
bool HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_is_valid(String inString);
String HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_sub(String inString0, int inStart, int inLen);
int HXCPP_EXTERN_CLASS_ATTRIBUTES _hx_utf8_decode_advance(char *&ioPtr);
#endif

415
Kha/Backends/Kinc-hxcpp/khacpp/include/hxcpp.h Executable file
View File

@ -0,0 +1,415 @@
#ifndef HXCPP_H
#define HXCPP_H
#include <kinc/global.h>
#ifdef __clang__
#pragma clang diagnostic ignored "-Wunused-variable"
#pragma clang diagnostic ignored "-Wunused-value"
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wshorten-64-to-32"
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wparentheses-equality"
#pragma clang diagnostic ignored "-Wconditional-uninitialized"
#pragma clang diagnostic ignored "-Wreorder"
#pragma clang diagnostic ignored "-Wself-assign"
#pragma clang diagnostic ignored "-Wint-to-void-pointer-cast"
#pragma clang diagnostic ignored "-Woverloaded-virtual"
#pragma clang diagnostic ignored "-Wsometimes-uninitialized"
#else
#pragma warning(disable : 4018 4101 4146 4244 4305 4127 4100 4267 4389 4201 4312 4244 4996 4457 4458 4189 4701 4702)
#endif
// Standard headers ....
#include <limits>
// Windows hack
#define NOMINMAX
#ifndef HXCPP_API_LEVEL
#define HXCPP_API_LEVEL 0
#endif
#include "hx/HeaderVersion.h"
#if defined(_MSC_VER) || defined(__BORLANDC__)
#if _MSC_VER >= 1423
#include <typeinfo>
#else
#include <typeinfo.h>
#endif
#if defined(__BORLANDC__)
namespace hx { typedef std::type_info type_info; }
#else
namespace hx { typedef ::type_info type_info; }
#endif
#else
#include <typeinfo>
#include <stdint.h>
#include <cstddef>
namespace hx { typedef std::type_info type_info; }
#ifndef EMSCRIPTEN
using hx::type_info;
#ifdef __MINGW32__
#include <stdint.h>
#else
typedef int64_t __int64;
#endif
#endif
#endif
#if defined(EMSCRIPTEN) || defined(IPHONE) || defined(APPLETV)
#include <unistd.h>
#include <cstdlib>
#endif
#if defined(EMSCRIPTEN)
#include <emscripten.h>
#endif
#ifdef __OBJC__
#ifdef HXCPP_OBJC
#import <Foundation/Foundation.h>
#endif
#endif
#include <string.h>
#include <wchar.h>
#ifdef HX_LINUX
#include <unistd.h>
#include <cstdio>
#include <stddef.h>
#endif
#if defined(EMSCRIPTEN) || defined(_ARM_) || defined(__arm__) || defined(GCW0)
#define HXCPP_ALIGN_FLOAT
#endif
// Must allign allocs to 8 bytes to match floating point requirement?
// Ints must br read on 4-byte boundary
#if defined(EMSCRIPTEN) || defined(GCW0)
#define HXCPP_ALIGN_ALLOC
#endif
#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
#if !defined(HXCPP_M64)
#define HXCPP_M64
#endif
#endif
// Some compilers are over-enthusiastic about what they #define ...
//#ifdef NULL
//#undef NULL
//#endif
#ifdef assert
#undef assert
#endif
#define HXCPP_CLASS_ATTRIBUTES
#ifdef _MSC_VER
#if defined(HXCPP_DLL_IMPORT)
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllimport)
#elif defined (HXCPP_DLL_EXPORT)
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __declspec(dllexport)
#else
#define HXCPP_EXTERN_CLASS_ATTRIBUTES
#endif
#else
#if defined(HXCPP_DLL_EXPORT)
#define HXCPP_EXTERN_CLASS_ATTRIBUTES __attribute__((visibility("default")))
#else
#define HXCPP_EXTERN_CLASS_ATTRIBUTES
#endif
#endif
typedef char HX_CHAR;
#if (defined(HXCPP_DEBUG) || defined(HXCPP_DEBUGGER)) && !defined HXCPP_CHECK_POINTER
#define HXCPP_CHECK_POINTER
#endif
#ifdef HX_WINRT
#define WINRT_LOG(fmt, ...) {char buf[1024];sprintf_s(buf,1024,"****LOG: %s(%d): %s \n [" fmt "]\n",__FILE__,__LINE__,__FUNCTION__, __VA_ARGS__);OutputDebugStringA(buf);}
#define WINRT_PRINTF(fmt, ...) {char buf[2048];sprintf_s(buf,2048,fmt,__VA_ARGS__);OutputDebugStringA(buf);}
#endif
#ifdef BIG_ENDIAN
#undef BIG_ENDIAN
#ifndef HXCPP_BIG_ENDIAN
#define HXCPP_BIG_ENDIAN
#endif
#endif
#ifdef __BIG_ENDIAN__
#ifndef HXCPP_BIG_ENDIAN
#define HXCPP_BIG_ENDIAN
#endif
#endif
#ifdef LITTLE_ENDIAN
#undef LITTLE_ENDIAN
#ifdef HXCPP_BIG_ENDIAN
#undef HXCPP_BIG_ENDIAN
#endif
#endif
#ifdef __LITTLE_ENDIAN__
#ifdef HXCPP_BIG_ENDIAN
#undef HXCPP_BIG_ENDIAN
#endif
#endif
// HX_HCSTRING is for constant strings with built-in hashes
// HX_GC_CONST_ALLOC_BIT | HX_GC_STRING_HASH
// HX_CSTRING is for constant strings without built-in hashes
// HX_GC_CONST_ALLOC_BIT
// HX_GC_CONST_ALLOC_BIT = 0x80000000
// HX_GC_STRING_HASH = 0x00100000
// HX_GC_STRING_CHAR16_T = 0x00200000
// For making generated code easier to read
#define HX_HASH_JOIN(A, B) A##B
#define HX_JOIN_PARTS(A, B) HX_HASH_JOIN(A, B)
#define HX_HASH_OF(A) #A
#define HX_HASH_OF_W(A) HX_HASH_JOIN(u,#A)
#define HX_STR_QUOTE(A) HX_HASH_OF(A)
#define HX_STR_QUOTE_W(A) HX_HASH_OF_W(A)
#define HX_HEX_QUOTE(hex) HX_STR_QUOTE(HX_JOIN_PARTS(\x,hex))
#define HX_HEX_QUOTE_W(hex) HX_STR_QUOTE_W(HX_JOIN_PARTS(\x,hex))
#ifdef HXCPP_BIG_ENDIAN
#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h3 h2 h1 h0 "\x80\x10\x00\x00" s)) + 8 , sizeof(s)/sizeof(char)-1)
#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h3) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h0) "\x80\x10\x00\x00" s )) + 8 , sizeof(s)/sizeof(char)-1)
#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x80\x00\x00\x00" s)) + 4 ,len)
#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h1) HX_HEX_QUOTE_W(h0) u"\x8030\x0000" s )) + 4, sizeof(s)/2-1)
#else
#define HX_HCSTRING(s,h0,h1,h2,h3) ::String( const_cast<char *>((h0 h1 h2 h3 "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
#define HX_(s,h0,h1,h2,h3) ::String( const_cast<char *>(( HX_HEX_QUOTE(h0) HX_HEX_QUOTE(h1) HX_HEX_QUOTE(h2) HX_HEX_QUOTE(h3) "\x00\x00\x10\x80" s )) + 8 , sizeof(s)/sizeof(char)-1)
#define HX_STRINGI(s,len) ::String( const_cast<char *>(("\x00\x00\x0\x80" s)) + 4 ,len)
#define HX_W(s,h0,h1) ::String( const_cast<char16_t *>(( HX_HEX_QUOTE_W(h0) HX_HEX_QUOTE_W(h1) u"\x0000\x8030" s )) + 4, sizeof(s)/2-1)
#endif
#define HX_STRI(s) HX_STRINGI(s,sizeof(s)/sizeof(char)-1)
#define HX_CSTRING(x) HX_STRI(x)
#define HX_CSTRING2(wide,len,utf8) HX_STRI(utf8)
#ifdef HX_SMART_STRINGS
#define HX_FIELD_EQ(name,field) (name.isAsciiEncoded() && !::memcmp(name.raw_ptr(), field, sizeof(field)/sizeof(char)))
// No null check is performedd...
#define HX_QSTR_EQ(name,field) (name.length==field.length && field.isAsciiEncodedQ() && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
// field is known to be isAsciiEncodedQ
#define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.raw_ptr(), field.raw_ptr() , field.length) )
#else
#define HX_FIELD_EQ(name,field) !::memcmp(name.__s, field, sizeof(field)/sizeof(char))
// No null check is performed....
#define HX_QSTR_EQ(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
#define HX_QSTR_EQ_AE(name,field) (name.length==field.length && !::memcmp(name.__s, field.__s, field.length))
#endif
#if defined(_MSC_VER)
#pragma warning(disable:4251)
#pragma warning(disable:4800)
#endif
#if defined(_MSC_VER) && _MSC_VER < 1201
#error MSVC 7.1 does not support template specialization and is not supported by HXCPP
#endif
// HXCPP includes...
// Basic mapping from haxe -> c++
#if (HXCPP_API_LEVEL<=330)
typedef int Int;
typedef bool Bool;
#endif
#ifdef HXCPP_FLOAT32
typedef float Float;
#else
typedef double Float;
#endif
// Extended mapping - cpp namespace
namespace cpp
{
typedef signed char Int8;
typedef unsigned char UInt8;
typedef char Char;
typedef signed short Int16;
typedef unsigned short UInt16;
typedef signed int Int32;
typedef unsigned int UInt32;
#ifdef _WIN32
typedef __int64 Int64;
typedef unsigned __int64 UInt64;
// TODO - EMSCRIPTEN?
#else
typedef int64_t Int64;
typedef uint64_t UInt64;
#endif
typedef float Float32;
typedef double Float64;
typedef volatile int AtomicInt;
};
// Extended mapping - old way
namespace haxe { namespace io { typedef unsigned char Unsigned_char__; } }
// --- Forward decalarations --------------------------------------------
class null;
namespace hx { class Object; }
namespace hx { class FieldRef; }
namespace hx { class IndexRef; }
namespace hx { class NativeInterface; }
namespace hx { struct StackContext; }
namespace hx { template<typename T> class Native; }
namespace hx { template<typename O> class ObjectPtr; }
namespace cpp { template<typename S,typename H> class Struct; }
namespace cpp { template<typename T> class Pointer; }
namespace cpp { template<typename T> class Function; }
template<typename ELEM_> class Array_obj;
template<typename ELEM_> class Array;
namespace hx {
class Class_obj;
typedef hx::ObjectPtr<hx::Class_obj> Class;
}
namespace cpp {
struct Variant;
class VirtualArray_obj;
class VirtualArray;
class CppInt32__;
}
#if (HXCPP_API_LEVEL < 320) && !defined(__OBJC__)
typedef hx::Class Class;
typedef hx::Class_obj Class_obj;
#endif
class Dynamic;
class String;
// Use an external routine to throw to avoid sjlj overhead on iphone.
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Throw(Dynamic inDynamic); }
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic Rethrow(Dynamic inDynamic); }
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void CriticalError(const String &inError, bool inAllowFixup=false); }
namespace hx { HXCPP_EXTERN_CLASS_ATTRIBUTES void NullReference(const char *type, bool allowFixup); }
namespace hx { extern String sNone[]; }
void __hxcpp_check_overflow(int inVal);
namespace hx
{
class MarkContext;
class VisitContext
{
public:
virtual void visitObject(hx::Object **ioPtr)=0;
virtual void visitAlloc(void **ioPtr)=0;
};
#if (HXCPP_API_LEVEL >= 330)
typedef ::cpp::Variant Val;
#else
typedef ::Dynamic Val;
#endif
#ifdef HXCPP_GC_GENERATIONAL
#define HXCPP_GC_NURSERY
#endif
//#define HXCPP_COMBINE_STRINGS
#if (HXCPP_API_LEVEL >= 313)
enum PropertyAccessMode
{
paccNever = 0,
paccDynamic = 1,
paccAlways = 2,
};
typedef PropertyAccessMode PropertyAccess;
#define HX_PROP_NEVER hx::paccNever
#define HX_PROP_DYNAMIC hx::paccDynamic
#define HX_PROP_ALWAYS hx::paccAlways
#else
typedef bool PropertyAccess;
#define HX_PROP_NEVER false
#define HX_PROP_DYNAMIC true
#define HX_PROP_ALWAYS true
#endif
} // end namespace hx
#define HX_COMMA ,
// The order of these includes has been chosen to minimize forward declarations.
// You should not include the individual files, just this one.
// First time ...
#include <hx/Macros.h>
#include <cpp/Variant.h>
#include <hx/ErrorCodes.h>
#include <hx/GC.h>
#include <hx/StackContext.h>
#include "null.h"
#include <hx/Object.h>
#include "hxString.h"
#include "Dynamic.h"
#include <cpp/CppInt32__.h>
// This needs to "see" other declarations ...
#include <hx/GcTypeInference.h>
#include <hx/FieldRef.h>
#include "Array.h"
#include <hx/Anon.h>
#include <hx/Class.h>
#include "Enum.h"
#include <hx/Interface.h>
#include <hx/Telemetry.h>
#if defined(__OBJC__) && defined(HXCPP_OBJC)
#include <hx/ObjcHelpers.h>
#endif
#include <hx/StdLibs.h>
#include <cpp/Pointer.h>
#include <hx/Native.h>
#include <hx/Operators.h>
#include <hx/Functions.h>
// second time ...
#include <cpp/Variant.h>
#include <hx/Debug.h>
#include <hx/Boot.h>
#include <hx/Undefine.h>
#if (HXCPP_API_LEVEL>=330)
#include <hx/LessThanEq.h>
#else
#include <cpp/Int64.h>
#endif
#endif

235
Kha/Backends/Kinc-hxcpp/khacpp/include/null.h Normal file
View File

@ -0,0 +1,235 @@
#ifndef HX_NULL_H
#define HX_NULL_H
// --- null value ---------------------------------------------------------
//
// This is used by external operatator and return statments - Most will
// use operator overloading to convert to the null pointer
// Forward declare ...
class String;
class null;
namespace hx { template<typename O> class ObjectPtr; }
namespace hx { null NullArithmetic(const char *inText); }
#define HX_NULL_COMPARE_OP(op,type,value) \
bool operator op (const type &inRHS) const { return value; }
#define HX_NULL_COMPARE_OPS(type) \
HX_NULL_COMPARE_OP(<,type,false) \
HX_NULL_COMPARE_OP(<=,type,false) \
HX_NULL_COMPARE_OP(>,type,false) \
HX_NULL_COMPARE_OP(>=,type,false) \
HX_NULL_COMPARE_OP(==,type,false) \
HX_NULL_COMPARE_OP(!=,type,true)
#define HX_NULL_COMPARE_MOST_OPS(type) \
HX_NULL_COMPARE_OP(<,type,false) \
HX_NULL_COMPARE_OP(<=,type,false) \
HX_NULL_COMPARE_OP(>,type,false) \
HX_NULL_COMPARE_OP(>=,type,false)
#define HX_COMPARE_NULL_OP(op,type,value) \
inline bool operator op (type inLHS, const null &) { return value; }
#define HX_COMPARE_NULL_OPS(type) \
HX_COMPARE_NULL_OP(<,type,false) \
HX_COMPARE_NULL_OP(<=,type,false) \
HX_COMPARE_NULL_OP(>,type,false) \
HX_COMPARE_NULL_OP(>=,type,false) \
HX_COMPARE_NULL_OP(==,type,false) \
HX_COMPARE_NULL_OP(!=,type,true)
#define HX_COMPARE_NULL_MOST_OPS(type) \
HX_COMPARE_NULL_OP(<,type,false) \
HX_COMPARE_NULL_OP(<=,type,false) \
HX_COMPARE_NULL_OP(>,type,false) \
HX_COMPARE_NULL_OP(>=,type,false)
#define HX_NULL_ARITHMETIC_OP(op) \
template<typename T> inline null operator op (T t) const \
{ return hx::NullArithmetic(#op); } \
inline null operator op (const null &) const \
{ return hx::NullArithmetic(#op); }
#define HX_ARITHMETIC_NULL_OP(op) \
template<typename T> inline null operator op (const T &, const null &) \
{ return hx::NullArithmetic(#op); }
class null
{
struct AnyArg
{
template<typename T>
inline AnyArg(const T&) { }
};
public:
inline null(){ }
template<typename T> explicit inline null(const hx::ObjectPtr<T> &){ }
template<typename T> explicit inline null(const String &){ }
explicit inline null(double){ }
explicit inline null(float){ }
explicit inline null(int){ }
explicit inline null(bool){ }
template<typename T>
T StaticCast() { return null(); }
operator bool () { return false; }
operator int () { return 0; }
operator unsigned int () { return 0; }
operator double () { return 0; }
operator float () { return 0; }
operator char () { return 0; }
operator unsigned char () { return 0; }
operator signed char () { return 0; }
operator short () { return 0; }
operator unsigned short () { return 0; }
operator cpp::UInt64 () { return 0; }
operator cpp::Int64 () { return 0; }
template<typename T>
inline operator typename hx::Native<T *> () const { return 0; }
// Any pointer!
//operator char * () { return 0; }
//operator wchar_t * () { return 0; }
template<typename T> operator T *() { return 0; }
bool operator == (null inRHS) const { return true; }
bool operator != (null inRHS) const { return false; }
bool operator == (null inRHS) { return true; }
bool operator != (null inRHS) { return false; }
template<typename T> inline bool operator == (const hx::ObjectPtr<T> &) const;
template<typename T> inline bool operator != (const hx::ObjectPtr<T> &) const;
template<typename T> inline bool operator == (const Array<T> &) const;
template<typename T> inline bool operator != (const Array<T> &) const;
inline bool operator == (const hx::FieldRef &) const;
inline bool operator != (const hx::FieldRef &) const;
inline bool operator == (const hx::IndexRef &) const;
inline bool operator != (const hx::IndexRef &) const;
inline bool operator == (const Dynamic &) const;
inline bool operator != (const Dynamic &) const;
inline bool operator == (const String &) const;
inline bool operator != (const String &) const;
inline bool operator == (const cpp::Variant &v) const { return v.isNull(); }
inline bool operator != (const cpp::Variant &v) const{ return !v.isNull(); }
inline null operator - () const { return hx::NullArithmetic("-"); }
inline null operator ! () const { return hx::NullArithmetic("!"); }
template<class T> T operator()(const AnyArg &a0=0, const AnyArg &a1=0, const AnyArg &a2=0,
const AnyArg &a4=0, const AnyArg &a5=0, const AnyArg &a6=0,
const AnyArg &a7=0, const AnyArg &a8=0, const AnyArg &a9=0 )
{
hx::NullReference("Function Call", false);
T nullDynamic;
return nullDynamic;
}
HX_NULL_COMPARE_OPS(bool)
HX_NULL_COMPARE_OPS(double)
HX_NULL_COMPARE_OPS(float)
HX_NULL_COMPARE_OPS(int)
HX_NULL_COMPARE_OPS(unsigned int)
HX_NULL_COMPARE_OPS(short)
HX_NULL_COMPARE_OPS(unsigned short)
HX_NULL_COMPARE_OPS(signed char)
HX_NULL_COMPARE_OPS(unsigned char)
HX_NULL_COMPARE_OPS(cpp::Int64)
HX_NULL_COMPARE_OPS(cpp::UInt64)
HX_NULL_COMPARE_MOST_OPS(String)
HX_NULL_COMPARE_MOST_OPS(Dynamic)
HX_NULL_COMPARE_MOST_OPS(hx::FieldRef)
HX_NULL_COMPARE_MOST_OPS(hx::IndexRef)
HX_NULL_COMPARE_OP(<,null,false)
HX_NULL_COMPARE_OP(<=,null,true)
HX_NULL_COMPARE_OP(>,null,false)
HX_NULL_COMPARE_OP(>=,null,true)
HX_NULL_ARITHMETIC_OP(+);
HX_NULL_ARITHMETIC_OP(*);
HX_NULL_ARITHMETIC_OP(-);
HX_NULL_ARITHMETIC_OP(/);
HX_NULL_ARITHMETIC_OP(%);
HX_NULL_ARITHMETIC_OP(&);
HX_NULL_ARITHMETIC_OP(|);
HX_NULL_ARITHMETIC_OP(^);
HX_NULL_ARITHMETIC_OP(>>);
HX_NULL_ARITHMETIC_OP(<<);
};
namespace hx
{
template<typename T>
struct Null
{
inline Null() : isNull(true) { }
inline Null(const Null<T> &inOther) : isNull(inOther.isNull), value(inOther.value) { }
inline Null(const T& inVal) : isNull(false), value(inVal) { }
inline Null(const null &) : isNull(true) { }
inline Null(const Dynamic &inVal)
{
isNull = null() == inVal;
if (!isNull)
value = inVal;
}
inline Null(const cpp::Variant &inVal)
{
isNull = inVal.isNull();
if (!isNull)
value = inVal;
}
inline operator Dynamic();
inline T Default(T inDefault) { return isNull ? inDefault : value; }
bool isNull;
T value;
};
} // end namesapce hx
typedef null Void;
HX_COMPARE_NULL_OPS(bool)
HX_COMPARE_NULL_OPS(double)
HX_COMPARE_NULL_OPS(float)
HX_COMPARE_NULL_OPS(int)
HX_COMPARE_NULL_OPS(unsigned int)
HX_COMPARE_NULL_OPS(short)
HX_COMPARE_NULL_OPS(unsigned short)
HX_COMPARE_NULL_OPS(signed char)
HX_COMPARE_NULL_OPS(unsigned char)
HX_COMPARE_NULL_OPS(cpp::UInt64)
HX_COMPARE_NULL_OPS(cpp::Int64)
HX_ARITHMETIC_NULL_OP(+)
HX_ARITHMETIC_NULL_OP(*)
HX_ARITHMETIC_NULL_OP(-)
HX_ARITHMETIC_NULL_OP(/)
HX_ARITHMETIC_NULL_OP(%)
HX_ARITHMETIC_NULL_OP(&)
HX_ARITHMETIC_NULL_OP(|)
HX_ARITHMETIC_NULL_OP(^)
HX_ARITHMETIC_NULL_OP(>>)
HX_ARITHMETIC_NULL_OP(<<)
// Other ops in Operator.h
inline void *_hx_nullptr() { return 0; }
#endif

20
Kha/Backends/Kinc-hxcpp/khacpp/java/org/haxe/HXCPP.java Normal file
View File

@ -0,0 +1,20 @@
package org.haxe;
// Wrapper for native library
public class HXCPP {
static boolean mInit = false;
static public void run(String inClassName) {
System.loadLibrary(inClassName);
if (!mInit)
{
mInit = true;
main();
}
}
public static native void main();
}

83
Kha/Backends/Kinc-hxcpp/khacpp/project/Build.xml Normal file
View File

@ -0,0 +1,83 @@
<xml>
<include name="${HXCPP}/build-tool/BuildCommon.xml"/>
<set name="dynamic_link" value="1" unless="static_link" />
<import name="libs/std/Build.xml" />
<import name="libs/zlib/Build.xml" />
<import name="libs/regexp/Build.xml" />
<import name="libs/mysql/Build.xml" />
<import name="libs/sqlite/Build.xml" />
<files id="msvccompat" >
<file name="StlLink.cpp"/>
</files>
<target id="msvccompat" output="${HX_TARGET_PREFIX}msvccompat${LIB_DBG}-${MSVC_VER}" tool="linker" toolid="${STD_MODULE_LINK}">
<files id="msvccompat"/>
<builddir name="libs/msvccompat"/>
<outdir name="${this_dir}/../${DESTDIR}/${BINDIR}"/>
</target>
<files id="linuxcompat" >
<file name="FdeltChk.c"/>
</files>
<target id="linuxcompat" output="${HX_TARGET_PREFIX}linuxcompat${HX_TARGET_SUFFIX}" tool="linker" toolid="${STD_MODULE_LINK}">
<files id="linuxcompat"/>
<builddir name="libs/linuxcompat"/>
<outdir name="${this_dir}/../${DESTDIR}/${BINDIR}"/>
</target>
<files id="nekoapi" >
<depend name="libs/nekoapi/neko.h"/>
<depend name="${HXCPP}/include/hx/Macros.h"/>
<depend name="${HXCPP}/include/hx/CFFI.h"/>
<file name="NekoAPI.cpp"/>
<compilerflag value="-Dneko_v1" if="neko_v1" />
</files>
<set name="neko_v2" value="1" unless="neko_v1" />
<set name="NEKO_LIB_DIR" value="bin/${BINDIR}" />
<target id="nekoapi" output="nekoapi" tool="linker" toolid="dll">
<ext value=".ndll"/>
<files id="nekoapi"/>
<builddir name="libs/nekoapi"/>
<lib name="${NEKO_LIB_DIR}/neko.lib" if="windows" />
<lib name="-L${NEKO_LIB_DIR}" unless="windows"/>
<lib name="-lneko" unless="windows"/>
<outdir name="${this_dir}/../bin/${BINDIR}"/>
</target>
<target id="default" if="linuxcompat" >
<target id="linuxcompat" />
</target>
<target id="default" unless="linuxcompat" >
<target id="std"/>
<target id="regexp"/>
<target id="zlib"/>
<target id="mysql"/>
<target id="sqlite" unless="winrt"/><!-- TODO -->
<section if="static_link">
<target id="msvccompat" if="windows" unless="mingw||MSVC19" />
<target id="linuxcompat" if="linux" />
<target id="linuxcompat" if="gcw0" />
</section>
</target>
</xml>

9
Kha/Backends/Kinc-hxcpp/khacpp/project/compile-cppia-arm64.hxml Normal file
View File

@ -0,0 +1,9 @@
-main cpp.cppia.Host
-D scriptable
-D dll_export=
-dce no
-cpp cppia_bin
-D HXCPP_ARM64
-D HXCPP_CATCH_SEGV
-D hxcpp_smart_strings
-D destination=../../bin/{BINDIR}/Cppia{EXESUFFIX}

9
Kha/Backends/Kinc-hxcpp/khacpp/project/compile-cppia.hxml Normal file
View File

@ -0,0 +1,9 @@
-main cpp.cppia.Host
-D scriptable
-D dll_export=
-dce no
-cpp cppia_bin
-D HXCPP_M64
-D HXCPP_CATCH_SEGV
-D hxcpp_smart_strings
-D destination=../../bin/{BINDIR}/Cppia{EXESUFFIX}

81
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/Makefile vendored Normal file
View File

@ -0,0 +1,81 @@
MBEDTLS_OLD = mbedtls-2.2.1
MBEDTLS_NEW = mbedtls-2.9.0
MBEDTLS_URL = https://tls.mbed.org/download/mbedtls-2.9.0-apache.tgz
all: purge upgrade
purge:
rm -rf $(MBEDTLS_OLD)
upgrade: $(MBEDTLS_NEW)
$(MBEDTLS_NEW):
curl $(MBEDTLS_URL) | gunzip | tar xf -
rm -rf $(MBEDTLS_NEW)/DartConfiguration.tcl \
$(MBEDTLS_NEW)/circle.yml \
$(MBEDTLS_NEW)/configs \
$(MBEDTLS_NEW)/doxygen \
$(MBEDTLS_NEW)/programs \
$(MBEDTLS_NEW)/scripts \
$(MBEDTLS_NEW)/tests \
$(MBEDTLS_NEW)/visualc \
$(MBEDTLS_NEW)/yotta
{ echo 'diff --git include/mbedtls/config.h include/mbedtls/config.h'; \
echo 'index 9585e692..5aa405bc 100644'; \
echo '--- include/mbedtls/config.h'; \
echo '+++ include/mbedtls/config.h'; \
echo '@@ -1480,6 +1480,9 @@'; \
echo ' * Uncomment this to allow your own alternate threading implementation.'; \
echo ' */'; \
echo ' //#define MBEDTLS_THREADING_ALT'; \
echo '+#ifdef HX_WINDOWS'; \
echo '+#define MBEDTLS_THREADING_ALT'; \
echo '+#endif'; \
echo ' '; \
echo ' /**'; \
echo ' * \def MBEDTLS_THREADING_PTHREAD'; \
echo '@@ -1491,6 +1494,9 @@'; \
echo ' * Uncomment this to enable pthread mutexes.'; \
echo ' */'; \
echo ' //#define MBEDTLS_THREADING_PTHREAD'; \
echo '+#ifndef HX_WINDOWS'; \
echo '+#define MBEDTLS_THREADING_PTHREAD'; \
echo '+#endif'; \
echo ' '; \
echo ' /**'; \
echo ' * \def MBEDTLS_VERSION_FEATURES'; \
echo '@@ -2206,7 +2212,7 @@'; \
echo ' *'; \
echo ' * This module provides networking routines.'; \
echo ' */'; \
echo '-#define MBEDTLS_NET_C'; \
echo '+//#define MBEDTLS_NET_C'; \
echo ' '; \
echo ' /**'; \
echo ' * \def MBEDTLS_OID_C'; \
echo '@@ -2570,7 +2576,7 @@'; \
echo ' *'; \
echo ' * Enable this layer to allow use of mutexes within mbed TLS'; \
echo ' */'; \
echo '-//#define MBEDTLS_THREADING_C'; \
echo '+#define MBEDTLS_THREADING_C'; \
echo ' '; \
echo ' /**'; \
echo ' * \def MBEDTLS_TIMING_C'; \
echo 'diff --git include/mbedtls/threading_alt.h include/mbedtls/threading_alt.h'; \
echo 'new file mode 100644'; \
echo 'index 00000000..71c2179d'; \
echo '--- /dev/null'; \
echo '+++ include/mbedtls/threading_alt.h'; \
echo '@@ -0,0 +1,7 @@'; \
echo '+#include <windows.h>'; \
echo '+'; \
echo '+typedef struct'; \
echo '+{'; \
echo '+ CRITICAL_SECTION cs;'; \
echo '+ char is_valid;'; \
echo '+} mbedtls_threading_mutex_t;'; \
} | patch -p0 -d $(MBEDTLS_NEW)
clean:
rm -rf $(MBEDTLS_NEW)

3
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/.globalrc vendored Normal file
View File

@ -0,0 +1,3 @@
default:\
:langmap=c\:.c.h.function:\

4
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/.mypy.ini vendored Normal file
View File

@ -0,0 +1,4 @@
[mypy]
mypy_path = scripts
namespace_packages = True
warn_unused_configs = True

79
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/.pylintrc vendored Normal file
View File

@ -0,0 +1,79 @@
[MASTER]
init-hook='import sys; sys.path.append("scripts")'
[BASIC]
# We're ok with short funtion argument names.
# [invalid-name]
argument-rgx=[a-z_][a-z0-9_]*$
# Allow filter and map.
# [bad-builtin]
bad-functions=input
# We prefer docstrings, but we don't require them on all functions.
# Require them only on long functions (for some value of long).
# [missing-docstring]
docstring-min-length=10
# No upper limit on method names. Pylint <2.1.0 has an upper limit of 30.
# [invalid-name]
method-rgx=[a-z_][a-z0-9_]{2,}$
# Allow module names containing a dash (but no underscore or uppercase letter).
# They are whole programs, not meant to be included by another module.
# [invalid-name]
module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+)|[a-z][-0-9a-z]+)$
# Some functions don't need docstrings.
# [missing-docstring]
no-docstring-rgx=(run_)?main$
# We're ok with short local or global variable names.
# [invalid-name]
variable-rgx=[a-z_][a-z0-9_]*$
[DESIGN]
# Allow more than the default 7 attributes.
# [too-many-instance-attributes]
max-attributes=15
[FORMAT]
# Allow longer modules than the default recommended maximum.
# [too-many-lines]
max-module-lines=2000
[MESSAGES CONTROL]
# * locally-disabled, locally-enabled: If we disable or enable a message
# locally, it's by design. There's no need to clutter the Pylint output
# with this information.
# * logging-format-interpolation: Pylint warns about things like
# ``log.info('...'.format(...))``. It insists on ``log.info('...', ...)``.
# This is of minor utility (mainly a performance gain when there are
# many messages that use formatting and are below the log level).
# Some versions of Pylint (including 1.8, which is the version on
# Ubuntu 18.04) only recognize old-style format strings using '%',
# and complain about something like ``log.info('{}', foo)`` with
# logging-too-many-args (Pylint supports new-style formatting if
# declared globally with logging_format_style under [LOGGING] but
# this requires Pylint >=2.2).
# * no-else-return: Allow the perfectly reasonable idiom
# if condition1:
# return value1
# else:
# return value2
# * unnecessary-pass: If we take the trouble of adding a line with "pass",
# it's because we think the code is clearer that way.
disable=locally-disabled,locally-enabled,logging-format-interpolation,no-else-return,unnecessary-pass
[REPORTS]
# Don't diplay statistics. Just the facts.
reports=no
[VARIABLES]
# Allow unused variables if their name starts with an underscore.
# [unused-argument]
dummy-variables-rgx=_.*
[SIMILARITIES]
# Ignore imports when computing similarities.
ignore-imports=yes

92
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/.travis.yml vendored Normal file
View File

@ -0,0 +1,92 @@
language: c
compiler: gcc
sudo: false
cache: ccache
jobs:
include:
- name: basic checks and reference configurations
addons:
apt:
packages:
- gnutls-bin
- doxygen
- graphviz
- gcc-arm-none-eabi
- libnewlib-arm-none-eabi
- gcc-arm-linux-gnueabi
- libc6-dev-armel-cross
language: python # Needed to get pip for Python 3
python: 3.5 # version from Ubuntu 16.04
install:
- scripts/min_requirements.py
script:
- tests/scripts/all.sh -k 'check_*'
- tests/scripts/all.sh -k test_default_out_of_box
- tests/scripts/all.sh -k test_ref_configs
- tests/scripts/all.sh -k build_arm_linux_gnueabi_gcc_arm5vte build_arm_none_eabi_gcc_m0plus
- name: full configuration
os: linux
dist: focal
addons:
apt:
packages:
- clang-10
- gnutls-bin
script:
# Do a manual build+test sequence rather than using all.sh,
# because there's no all.sh component that does what we want,
# which is a build with Clang >= 10 and ASan, running all the SSL
# testing.
# - The clang executable in the default PATH is Clang 7 on
# Travis's focal instances, but we want Clang >= 10.
# - Running all the SSL testing requires a specific set of
# OpenSSL and GnuTLS versions and we don't want to bother
# with those on Travis.
# So we explicitly select clang-10 as the compiler, and we
# have ad hoc restrictions on SSL testing based on what is
# passing at the time of writing. We will remove these limitations
# gradually.
- make CC=clang-10 CFLAGS='-Werror -Wall -Wextra -fsanitize=address,undefined -fno-sanitize-recover=all -O2' LDFLAGS='-Werror -Wall -Wextra -fsanitize=address,undefined -fno-sanitize-recover=all'
- make test
- programs/test/selftest
- tests/scripts/test_psa_constant_names.py
# Exclude a few test cases that are failing mysteriously.
# https://github.com/Mbed-TLS/mbedtls/issues/6660
- tests/ssl-opt.sh -e 'Fallback SCSV:\ .*list'
# Modern OpenSSL does not support fixed ECDH, null or ancient ciphers.
- tests/compat.sh -p OpenSSL -e 'NULL\|ECDH-\|DES\|RC4'
- tests/scripts/travis-log-failure.sh
# GnuTLS supports CAMELLIA but compat.sh doesn't properly enable it.
# Modern GnuTLS does not support DES.
# One NULL cipher suite is strangely missing in pre-1.2 protocol
# versions (it works with (D)TLS1.2, but don't bother).
- tests/compat.sh -p GnuTLS -e 'CAMELLIA\|DES\|TLS-RSA-WITH-NULL-SHA256'
- tests/scripts/travis-log-failure.sh
- tests/context-info.sh
- name: Windows
os: windows
script:
- scripts/windows_msbuild.bat v141 # Visual Studio 2017
after_failure:
- tests/scripts/travis-log-failure.sh
env:
global:
- SEED=1
- secure: "JECCru6HASpKZ0OLfHh8f/KXhKkdrCwjquZghd/qbA4ksxsWImjR7KEPERcaPndXEilzhDbKwuFvJiQX2duVgTGoq745YGhLZIjzo1i8tySkceCVd48P8WceYGz+F/bmY7r+m6fFNuxDSoGGSVeA4Lnjvmm8PFUP45YodDV9no4="
addons:
apt:
packages:
- gnutls-bin
coverity_scan:
project:
name: "ARMmbed/mbedtls"
notification_email: support-mbedtls@arm.com
build_command_prepend:
build_command: make
branch_pattern: coverity_scan

76
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/BRANCHES.md vendored Normal file
View File

@ -0,0 +1,76 @@
# Maintained branches
At any point in time, we have a number of maintained branches consisting of:
- The [`master`](https://github.com/Mbed-TLS/mbedtls/tree/master) branch:
this always contains the latest release, including all publicly available
security fixes.
- The [`development`](https://github.com/Mbed-TLS/mbedtls/tree/development) branch:
this is where new features land,
as well as bug fixes and security fixes.
- One or more long-time support (LTS) branches:
these only get bug fixes and security fixes.
We use [Semantic Versioning](https://semver.org/). In particular, we maintain
API compatibility in the `master` branch between major version changes. We
also maintain ABI compatibility within LTS branches; see the next section for
details.
## Backwards Compatibility for application code
We maintain API compatibility in released versions of Mbed TLS. If you have
code that's working and secure with Mbed TLS x.y.z and does not rely on
undocumented features, then you should be able to re-compile it without
modification with any later release x.y'.z' with the same major version
number, and your code will still build, be secure, and work.
Note that this guarantee only applies if you either use the default
compile-time configuration (`mbedtls/config.h`) or the same modified
compile-time configuration. Changing compile-time configuration options can
result in an incompatible API or ABI, although features will generally not
affect unrelated features (for example, enabling or disabling a
cryptographic algorithm does not break code that does not use that
algorithm).
There are rare exceptions: code that was relying on something that became
insecure in the meantime (for example, crypto that was found to be weak) may
need to be changed. In case security comes in conflict with backwards
compatibility, we will put security first, but always attempt to provide a
compatibility option.
For the LTS branches, additionally we try very hard to also maintain ABI
compatibility (same definition as API except with re-linking instead of
re-compiling) and to avoid any increase in code size or RAM usage, or in the
minimum version of tools needed to build the code. The only exception, as
before, is in case those goals would conflict with fixing a security issue, we
will put security first but provide a compatibility option. (So far we never
had to break ABI compatibility in an LTS branch, but we occasionally had to
increase code size for a security fix.)
For contributors, see the [Backwards Compatibility section of
CONTRIBUTING](CONTRIBUTING.md#backwards-compatibility).
## Backward compatibility for the key store
We maintain backward compatibility with previous versions of the
PSA Crypto persistent storage since Mbed TLS 2.25.0, provided that the
storage backend (PSA ITS implementation) is configured in a compatible way.
We intend to maintain this backward compatibility throughout a major version
of Mbed TLS (for example, all Mbed TLS 3.y versions will be able to read
keys written under any Mbed TLS 3.x with x <= y).
Mbed TLS 3.x can also read keys written by Mbed TLS 2.25.0 through 2.28.x
LTS, but future major version upgrades (for example from 2.28.x/3.x to 4.y)
may require the use of an upgrade tool.
## Current Branches
The following branches are currently maintained:
- [master](https://github.com/Mbed-TLS/mbedtls/tree/master)
- [`development`](https://github.com/Mbed-TLS/mbedtls/)
- [`mbedtls-2.28`](https://github.com/Mbed-TLS/mbedtls/tree/mbedtls-2.28)
maintained until at least the end of 2024, see
<https://github.com/Mbed-TLS/mbedtls/releases/tag/v2.28.2>.
Users are urged to always use the latest version of a maintained branch.

20
Kha/Backends/Kinc-hxcpp/khacpp/project/thirdparty/mbedtls-2.28.2/BUGS.md vendored Normal file
View File

@ -0,0 +1,20 @@
## Known issues
Known issues in Mbed TLS are [tracked on GitHub](https://github.com/Mbed-TLS/mbedtls/issues).
## Reporting a bug
If you think you've found a bug in Mbed TLS, please follow these steps:
1. Make sure you're using the latest version of a
[maintained branch](BRANCHES.md): `master`, `development`,
or a long-time support branch.
2. Check [GitHub](https://github.com/Mbed-TLS/mbedtls/issues) to see if
your issue has already been reported. If not, …
3. If the issue is a security risk (for example: buffer overflow,
data leak), please report it confidentially as described in
[`SECURITY.md`](SECURITY.md). If not, …
4. Please [create an issue on on GitHub](https://github.com/Mbed-TLS/mbedtls/issues).
Please do not use GitHub for support questions. If you want to know
how to do something with Mbed TLS, please see [`SUPPORT.md`](SUPPORT.md) for available documentation and support channels.

Some files were not shown because too many files have changed in this diff Show More