## [0.11.0] - 2021-1-29
- The NuGet package now supports Linux and macOS as well
- Upgrade to .NET Core 3.1 and improve build system
- Make auto-compiling of C# work with .NET Core
- Adding extract interface pass
- Add a log for changes per release
- Fixed alias of signed char cannot be marshaled
- Add missing quotes to support paths with spaces in build scripts
- Ignore the still unsupported dependent type names
- Rewrite GenerateEnumFromMacros helper to also look into enum items.
- Fix generation of overloads in NAPI by re-ordering final calculated states.
- Update expression evaluator code from latest upstream.
- Improve visiting options implementation in CodeGenerator.
- Clean multiline function signatures in the AST converter.
- Fix generation of text blocks using NewLineKind.IfNotEmpty.
- Git ignore IDEA project folders.
- Change XML comments to be tested at run-time
- Generate valid C++ for pointers in template args
- Better detect invalid specialized functions
- Simplify the marking of invalid functions
- Generate valid C++ for protected constructors
- Generate valid C++ for protected destructors
- Only implement abstract classes in C++ for ctors/dtors
- Fix test generation for QuickJS generator.
- Remove unused code in QuickJS module generator.
- Add enum support to QuickJS generator.
- Marshaling correctness fix for enum and primitive types in NAPI.
- Abstract marshaler into overridable method in NAPI sources.
- Extract NAPI VarPrefix and ArgumentPrefix to base class.
- Add missing clang headers
- Create a single nuget package that supports windows / linux / macos
- Refactor QuickJS generator structure to follow NAPI patterns.
- Add initial QuickJS primitive type support and test suite.
- Ensure a tested specialization is really generated
- Place all output of tests in their own directories
- Use C++17 in all native projects
- Disable getter/setter to property pass by default in non-managed backends.
- Fix forward include collector to consider value class semantics in function returns.
- Factor VarPrefix and ArgumentPrefix helpers into base marshaler.
- Implement basic visiting behavior in some CodeGenerator overloads.
- Normalize visiting overloads to be virtual.
- Flush `Module.ExternalClassTemplateSpecializations` to avoid emitting the same specialization in multiple files
- Add initial Node and N-API testing infrastructure and tests.
- Big update to NAPI generator with initial support for basic examples.
- Add DFA/NFA state machine utility code.
- Replace outdated Clang compiler flags such as `std=c++1z` and replace it with `std=c++17`
- Change `GenerateSequentialLayout` default value to `true`
- Simplify TU.FileRelativeDirectory by using Path.GetDirectoryName.
- Update driver to only generate system modules for C# generators.
- Add ILibrary.GenerateCode as a custom code generation callback.
- Upgrade .NET projects to C# 8.0.
- Improve generation of type printing declaration names for C language.
- Rework constructor generation in C++ code generator.
- Setup include dirs on the module instead of parser options in the CLI.
- Improve error handling in CLI and avoid defaulting to a generator on unknown option..
- Add N-API generator support to the CLI.
- Extract and re-use GetIncludePath across multiple generators.
- Fix TU.FileRelativeDirectory to be more robust against some paths.
- Fully resolve include dirs paths in driver option validation.
- Fix ShouldGenerateClassNativeField to use NeedsBase instead of HasBase.
- Update Class.HasNonIgnoredBase to use the actual base class.
- Fix rename pass not handling some declarations due to early return.
- Manage package versions centrally
- Add `LanguageVersion.CPP20` support
- Only upload artifacts from master branch
- Make unit tests independent of the generator
- Simplify code that regenerates test bindings
- Only use premake for native projects and improve c# projects.
- Move GeneratorTestFixture type to its own file.
- Fix typo and move alignment offsets to cpp file
- Export or implement accessible functions in tests
- Export symbols for indirectly accessible constructors
- Publish artifacts for CI builds (#1533)
- Fix importing/exporting redeclaration in symbols
- CI: Add `Restore` step to make it easier to analyze build times
- Don't warn repeatedly about an existing LLVM dir
- Don't download LLVM if its destination exists
- Fix the expression-generator after changed paths
- Fix a regressive crash when generating parser bindings
- Remove redundant overrides from the generated C++/CLI
- Disable the msvc warning about unexported template specializations
- Fix naive version comparison
- Fix GCC version detection
- Move all LLVM files to /build/llvm
- Ignore premake5 binaries
- Remove secondary Zstandard compression from LLVM packages
- Show a message explaining how to build LLVM when a pre-built package is unavailable.
- Fix wrong LLVM package name when GCC version is >= 10
- Add LLVM commands to build.sh
- Test using a specialization from a dependent module
- Add install_tools target to build.sh and fix LLVM CI.
- Deprecate GCC 7 and add GCC 10 build for LLVM CI.
- Move generated .vcxproj files back to their original place
- Add missing `-configuration` option to build.sh script
- Replace Generate*.bat files with a single generate.sh which uses VS2019 by default
- Remove DownloadDeps.bat file
- Add build.sh and test.sh with execute permissions
- Only search for MSVC toolchain in Windows
- Generate correct LLVM package name regardless of the current operating system
- Avoid using "action:vs* filter because there are better ones that are more specific (#1523)
- Convert the visiting options to an enum
- Update CanCheckCodeGenInfo to check function types as well.
- Check for a dependent expression before walking variable initializer.
- Some Premake robustness fixes for Clang toolchain.
- Use explicit native type printer kind in CLI headers code.
- Ignore testing the incorrect marshalling of parameters typed const& to primitives
- Don't check the unsupported operator= for symbols
- Add initial NAPI and JS generator.
- Add initial QuickJS generator.
- Add C++ generator support to the CLI.
- Remove artificial limitations for cross-generation in CLI.
- Simplify target-specific message output code in CLI.
- Add a new option to set a prefix for generated files in CLI.
- Improve module naming heuristics and add an option for setting it explicitly.
- Implement C support as generator kind in CLI.
- Refactor string.Format calls in CLI.
- Implement Method.HasSameSignature for signature comparison.
- Implement Method.ToString() to help with debugging.
- A temporary hack to deal with a bug in MSVC v142 - VS 2019 build tools
- Don't wrap trivial constructors and destructors
- Ensure bindings are regenerated as needed without using DisableFastUpToDateCheck (#1511)
- Continue implementation of C++ generator.
- Add pass to fix up pure C++ methods to C++ generator.
- More robust C++ type printing of incomplete class declarations.
- Save existing parameter when doing C++ parameter type printing.
- Add initial C base generator.
- Check if module exists before using it in C code generator.
- More robust enum generation for C family languages in C code generator.
- Fix C generator GenerateMethodSpecifier to support pure and const specifiers.
- Add set of generated declarations to CLITypeReferences.
- Add initial block visitor to GeneratorOutputPass.
- Only add files to module if module is not null.
- Add per-declaration support for decl maps.
- Add BlockGenerator.NeedsNewLine helper property.
- Fix class nested enums to be handled by the rename pass.
- Document recently added GenerationOutputMode option.
- Add TypeQualifiersMode to Type and implement in C++ type printer.
- Add new VisitQualifiedType overload to visitors.
- Set include path as weell as file path when creating a new TU.
- Fix IsGeneratedOverride to take virtual methods into account.
- Add some helper class hierarchy methods.
- Fix CppMarshal WriteClassInstance to deal with incomplete classes.
- Rework Generator interface and add GenerationOutputMode option.
- Improve IsTypeComplete to be more robust.
- Improve ignored check for decls with explicit generation kinds.
- Generate acessor methods for C targets in field to property pass..
- Set the correct enum integer type in GenerateEnumFromMacros.
- Fix ignored base checking in CheckIgnoredDecls.
- Be more strict when constructing a regex for parsing macros.
- Handle enum items in rename pass.
- Fix code to use BaseClass property instead of first base.
- Add initial implementation of declaration maps.
- Remove unsupported Visual Studio versions from generate options
- Rename GenerateProjects.bat to Generate.bat
- Add GenerateVS2019.bat shortcut similar to GenerateMake.bat
- Prevent projects from picking up obj files that are generated sometimes (#1508)
- Fix all of our warnings in the parser
- Fix error in Tests.lua by requiring gmake2 module.
- Add a GCC 9 build to the LLVM CI build matrix.
- Fix minor issue when invoking Premake without an action.
- Compress LLVM archives using zstd.
- Call MSBuild in x86 build with Win32 platform.
- Pass the target architecture when building LLVM.
- Publish artifacts after building LLVM.
- Fix VS environment paths by setting global env variables.
- Do not use LLD when building LLVM under macOS.
- Generate C++ for constructors of abstract types
- Use NUnit3TestAdapter package (#1504)
- Add a build for LLVM to the CI
- Use correct C# parser bindings for windows x64 (#1501)
- Avoid installing NUnit if its already installed. (#1500)
- Generate code from tests where libraries appear
- Fix generation of SequentialLayout structures (#1499)
- Update parser bindings. (#1497)
- Fix CS0162 warning about unreachable code (#1492)
- Fix CS0109 warnings about new keyword not being required. (#1493)
- Enable Multi-processor Compilation (MSVC)
- Fix C4273 warnings about inconsistent dll linkage (#1491)
- Fix warnings about unnecessary using directives. (#1489)
- Fix C4251 warnings (#1487)
- Avoid generating an interface with a Dispose method if we already inherit from IDisposable. (#1486)
- Fix finding of symbols for members of templates
- Always ignore warnings about missing PDB files
- Reduce number of "download progress" messages. (#1482)
- Mark variables with constant expressions as found
- Make the CPP ABI visible only to the STD symbols
- Generate valid C++ for destructors of nested types
- Always use the mangled names as reported by Clang
- Switch CI to GitHub Actions
- Call the destructor instead of deleting the object in the generated symbols
- Regenerate the parser bindings with sequential layouts (#1479)
- Remove dummy variable and use discards instead available since C# 7.0 (#1478)
- Fallback to LayoutKind.Explicit when a custom alignment is specified. (#1476)
- Remove `Layout.GetSize()` method as it's no longer relevant (#1474)
- Fix `String.CSharpSignatureType` returning incorrect type when the given type is a pointer or a reference. (#1473)
- Expose if a variable is a constant expression
- Fix the generation of sequential layouts
- Create projects which always build generated code
- Simplify the marshalling of returned pointers (#1470)
- VTable: improve codegen & make it thread safe (#1469)
- Create VTables class to cache delegates pointing to native virtual methods (#1468)
- Improve UTF32Marshaller performance (#1467)
- Improve generation of C# (#1466)
- Reduce calls to ConcurrentDictionary to improve performance (#1464)
- Ensure expression is a valid float constant before trying to append `f` suffix (#1465)
- Fix passing of CMake options to LLVM on Windows
- Update the kind of completed specializations (#1460)
- Fix ambiguous conversion functions (#1458)
- Prevent string destructor from being called twice when its passed by value (#1455)
- Remove unsupported calling convention usage (#1454)
- Fix PInvokeStackImbalance when calling C++ methods (#1453)
- Load symbols at startup to avoid very expensive ResolveSymbol calls everywhere (#1447)
- Fix IntPtr array marshalling bug and move hard to read code to CppSharp.Runtime (#1446)
- Fix string marshalling bug and move hard to read code to CppSharp.Runtime (#1445)
- Add support for const char32_t* and fix const wchar_t* in linux / osx (#1444)
- Copy arrays of primitive values using System.Buffers.MemoryCopy (#1440)
- Fix marshalling for bool arrays (#1439)
- Fix wrong [MarshalAs(UnmanagedType)] for strings (#1438)
- Remove call argument to fix broken build (#1436)
- Basic support for static constexpr variables (#1435)
- Add support for C++ character literals (u, U, L) (#1434)
- Upgrade premake in preparation for .NET Core (#1298)
- Use C# 'default literal' to avoid using a type's name that may be renamed (#1432)
- Add missing `Variable.Type` null check. (#1430)
- Fix generated constructor cant use `placement new` when class overloads `operator new` (#1431)
- Fix generation of VS projects under non-Windows platforms.
- Fix wrong marshalling for static member arrays (#1428)
- Fix wrong generated destructor
- Ignore non-const data() method for std types like basic_string [c++17] (#1427)
- Fix crash when trying to read a CXXRecordDecl that doesn't have a definition (#1426)
- RemovePass is now generic.
- Added the ability to remove a built-in pass.
- Fix anonymous member name colliding with enclosing type name (#1425)
- Allow the users to overwrite CppSharp type maps.
- Find libraries even when given with no extensions
- Add an option for building with Visual Studio 2019
- Fix GCC path detection for Ubuntu 20.
- Move libraries to a new class for linking options
- Fix memory leaks when using the driver
- Simplify ClangParser by making it static
- Pack the lld headers as well
- Import native DLL-s (tests and parser) with MSVC
- Implement and export all methods in tests
## [0.10.5] - 2020-6-27
- Don't add ABI-specific parameters when wrapping C
- Prioritize public non-field properties when resolving naming conflicts
- Fix patching of virtual tables for MSVC with RTTI
- Free the memory of the patched v-tables
- Fix parsing of member pointers with MSVC
- Generate valid C# for constructors taking const&
- Generate valid C# for returned function pointers
- Expose returned values of non-void setters
- Ensure enumerations lack conflicts when renamed
- Fix generation for fields of type const reference
## [0.10.4] - 2020-5-23
- Simplify the required headers for macOS bindings
- Option to allow caller to specify it does not want unchanged output files to be modified. This supports incremental build in VS. (#1373) - Ali Alamiri <ali.alamiri@sage.com>
- CreateInstance factory overload to pass flag informing wrapper if it should own the native pointer passed to it. - Ali Alamiri <ali.alamiri@sage.com>
- force bash use to avoid `./premake5-linux: 3: ./premake5-linux: Bad substitution` error if other default shell in the system - Lorenzo Delana <lorenzo.delana@gmail.com>
- Made the original virtual tables static too
- Pass native pointers to bases in the generated C#
- Check type maps when printing C++ for pointers
- Do not add type alias templates twice to the AST
- Fix all leaks of memory in the old expressions
- Add template functions to their context
- Fix leaking memory by removing a useless assignment
- Fix leaking the memory of an entire Clang AST
- Ignore type maps when printing C++ for symbols
- Implement more accurate managed type printing in C++ type printer.
- Use a native type printer context when looking for type maps in CSharpSourcesExtensions.DisableTypeMap.
- Use explicit type printer when printing types in C# GenerateMethodSpecifier.
- Refactor CodeGenerator.GenerateMethodSpecifier to allow explicit specifier kind.
- Do not check declaration access for explicitly generated declarations.
- Fix TranslationUnit.FileRelativeDirectory to be more robust against null include paths.
- Fix formatting to of Declaration.GenerationKind to ease debugging.
- Ignore implicitly deleted copy constructor methods.
- Correctly marshal constant arrays in C++/CLI (#1346)
- Marshal pointer to primitive typedefs in C++/CLI (#1355) - Ali Alamiri <ali.alamiri@sage.com>
- Fix a regression when renaming classes
- Fix naming conflicts with nested types and members
- publish the clang lib folder - Ali Alamiri <ali.alamiri@sage.com>
- Implement basic support for parsing function-like macros.
- Implement TranslationUnit.ToString() to help with debugging.
- Add debug option and flags to the Premake build and compile scripts.
- Generate valid C# for parameters typedef-ed to mapped types
- Update the version of Mono used for builds (CI)
- Fix the regressed C# marshalling of char*
- Handle pointer to pointer param (#1343) - Ali Alamiri <ali.alamiri@sage.com>
- Handle returned pointers to std::vector in C++/CLI - Ali Alamiri <ali.alamiri@sage.com>
- Implement abstract templates to call virtuals
- Correctly align printed information for debugging
- Set the render kind of inline command comments
- Fix all memory leaks in tests
- Generate by ref parameters of type a pointer to enum
- Use UnsupportedType description for type name instead of empty string (#1339) - Ali Alamiri <ali.alamiri@sage.com>
## [0.10.3] - 2020-4-9
- Ensure complete template specializations in AST
- Add an option and checking for generation of deprecated declarations
- Implement parsing and AST processing of C++ deprecated attributes
- Make sure we use a native type printer for symbols code generation
- Git ignore new include folders for cross generation
- Fix marshaling for wchar_t in C++ generator mode
- Fix includes setup for parser bindings generation in macOS host platform
- Fix generation of field property setters in C++ generator
- Fix FieldToProperty pass to ignore non-public properties in C++ generator
- Fix declaration access for generated fields flattened from anonymous types
- Change standard type maps to be more specific about its supported generators
- Generate forward ref header for enum defined inside a class in C++/CLI (#1322) - Ali Alamiri
- Move the GenerateInclude logic to GetTypeReference (#1319) - Ali Alamiri
- By reference enum param fixes (#1321) - Ali Alamiri
- Add declaration context as object to function class block - Ali Alamiri
- Add blocks for ctor, dtor, and finalizer bodies. Add constructor that takes a bool from the caller to indicate if the callee should own the pointer passed to it or not - Ali Alamiri
- Add generic type map handling methods for later refactoring of generators
- Fix type printing of typedef qualifiers in C++ type printer
- Fix C++ parser ambiguity in generation of C++ method identifiers by wrapping them in parens
- Fix generation of C++ constructor for abstract classes
- Fix generation of native instance constructors in C++ generator
- Fix marshaling of C++ references in C++ marshaler
- Minor refactoring to allow better IDE inspection and debugging
- Rewrite GenerateEnumFromMacros to search through multiple translation units
- Fix CppTypePrinter to check for typemaps for tag types and keep track of them
- Implement a few overloads in CppTypePrinter that trigger the type maps checking code
- Fix ignore type checking to take type maps into account
- Fix ignored declaration checking to properties desugar field types
- Fix GetterSetterToProperty pass heuristic to also detect “on” as a verb
- CppTypePrinter now takes a BindingContext for further usage in type maps handling
- Only generate “override” in header files for C++ generator
- Guard MoveFunctionToClassPass pass registration against CLI and C# generators
- Ignore generated field method acessors when processing properties in GetterSetterToProperty
- Add cli namespace to header to ensure the array type does not conflict with other types called array - Ali Alamiri
- Marshal non primitive fixed arrays (#1311) - Ali Alamiri
- Ensure typedefs of std::vector are mapped - Ali Alamiri
- Simplify the structure of the LLVM package
- Always keep default constructors in the AST
- Keep copy/move constructors and assignment in AST
- Move the body of a template function to its header
- Implement proper array printing with C array name suffix notation
- Fix CLITypeReferences so it generates regular C++ code in C++ generator mode
- Add CXXOperatorArityZero enum item for further usage in subsequent code
- Initial C++ generator backend
## [0.10.2] - 2020-3-28
- Associate getter/setter methods with their associated property in GetterSetterToProperty pass
- Added optional getter/setter pair creation for fields in FieldToProperty pass
- Refactor CLI handling of enums to be based on generic C generator
- Default to .h file extension in C code generator
- Add helper methods to ignore and generate specific translation units
- Guard a few more language-specific passes in the driver
- Fix generation of multiple interfaces in C# for some edge cases
- Fix templates to be abstract if any specialization is abstract
- Fix TranslationUnit.FileRelativePath for invalid units
- Re-use common C++ declaration type printing code in CLITypePrinter
- Allow changing the default TypePrinterContextKind when creating a type printer
- Remove needless pointer offsets from generated C#
- Fix a crash for secondary bases with secondary bases
- Fix bug related to processing of potential property methods
- Ensure generated symbols can use placement new
- Fix Mono not being found on the PATH on recent macOS versions
- Instantiate exception specifications before reading
- Update LLVM to the latest version
- Fix a syntax error in CMake listing Clang modules
- Enable building lld as part of LLVM
- Restore modules needed for compiling with Clang
- Support Visual Studio 2019 for building Clang
- Update Travis to Ubuntu Xenial 18.04
- Simplify and optimize the printing of pointers in C++
- Fix printing of function pointers in C++
- Don't export symbols for explicit specializations
- Avoid invalid template specializations in tests
- Update the printing of comments to the new Clang
- Work around MSVC 32 crashing reading of exported symbols in Mach-O
- Improve Xcode toolchain lookup to be more robust
- Implement logic for -fgnuc-version= argument required by LLVM
- Update LLVM to the latest version
- Refactor Clang builtins directory logic and move it to the managed side
- Escape C# strings correctly
- Improve CS_INTERNAL so it now applies to all declarations
- Print the parser target triple in verbose mode
- Always re-create the Clang resource directory when building
- Cleanup Clang resource directory lookup logic
- Remove old workaround for testing issue that does not seem necessary anymore
- Git ignore .vscode directory
- Workaround Premake issue when copying the resource include directories at build time
- Fix warning about #pragma once in source file
- Update bootstrap tool to run against latest LLVM
- Update bootstrap tool to find LLVM build directory
- Add options to disable tests and examples from the build
- Improve the ignoring of dependent name types
- Implement UnresolvedUsingType and UnresolvedUsingTypename
- Fix the tests for exception types
- Switch to Xcode 11 in Travis CI
- Extend printing and reading of exception types
- Fix the check to ignore dependent name types
- Ignore unused destructors when generating symbols
- Fix the printing of "noexcept" in C++
- Make destructors virtual in abstract classes for tests
- Avoid generating abstract implementations for template classes
- Fix template type checking in CovariantTypeComparer
- Git ignore nested temporary obj folders
- Workaround System.TypeLoad exception when running test-suite on macOS
- Fix enum with zeros for hex literals
- Fix the moving of free functions to classes to match by module too
- Generate valid C# when an external module has an unsupported operator
- Fix a possible overflown stack when ignoring
- Force compilation of all functions of specializations
- Fill in missed values when cloning functions
- Optimize the moving of functions to classes
- Delete a custom pass added as standard
- Fix the C++ printing of function pointers in parameters
- Eliminate generated symbols for ignored functions
- Fix printing of type defs in C++
- Remove the internal C# functions for virtual destructors
- Give unique names to exported inlined functions
- Generate symbols for methods of specializations
- Optimize all passes which visited useless items
- Make the pass for properties more extendable
- Simplify overrides of overrides of secondary bases
- Optimize calls to base getters in properties
- Fix comparison of char and const char* in overloading
- Optimize the pass for properties
- Clarify limitations around exceptions and RTTI
- Destroy returned by value std::strings
- Upgrade ANSI marshalling to UTF-8 marshalling
- Generate valid C# when a renamed override causes conflicts
- Ensure protected nested types are accessible with multiple inheritance
- Fix the regressed indentation of printed comments
- Generate projects for .NET 4.7 to use new features
- Simplify the generated C# for marshalling strings
## [0.10.1] - 2019-7-4
- Fix the getting of references to pointers in C#
- Fix the passing of references to pointers in C#
- Prefer non-mapped types when resolving ambiguous overloads
- Make indexers use non-trivial copy ctors if any
- Fix a memory leak when passing an indirect std::string
- Build the generator before test bindings for easy testing
- Fix memory leaks in the map for std::string
- Fix the passing of std::string by value
- Guard against null for objects passed by value
- Generate valid C# for implicit conversion to const char*
## [0.10.0] - 2019-6-25
- Generate valid C# when passing a const ref to char
- Generate valid C# when a secondary base has a public anonymous field
- Generate valid C# when a method from a secondary base has no native symbol
- Generate valid C# for typedef-ed type parameters
- Ensure found type maps always contain the type sought after
- Flatten anonymous types to avoid empty names
- Generate valid C# for template parameters with a default value
- Fix returned objects by value attributed with inalloca
- Fix default arguments to only map to null if pointers
- Generate valid C# for returned const void pointers
- Fix regressions with void pointers and references
- Generate valid C# for r-values to void pointers
- Make the default build for Windows 64-bit
- Sped the LLVM build on Windows up by parallelizing
- Generate valid C# when a field with an anon type starts with '$'
- Generate valid C# when a function is named "get<number>"
- Enable Clang-based look-up for system includes by default
## [0.9.2] - 2019-5-8
- Fix the Windows build by not storing Unicode in std::string
- Fixed type map support for typedef types
- Name anonymous types after the fields which use them
- Generate valid C# when std::string is only used for variables
- Generate valid C# when std::string is only used for non-private fields
- Support indirect parameters
- Add a test for passing by value of structs with copy ctors
- Add parsing and AST support for RecordArgABI information in class records.
- Fix the generated C++ for Xcode 10.2
- Optimize renaming of declarations named after keywords
- Optimize the cleaning of invalid names
- Fix a crash when a function pointer takes a function pointer
- Generate valid C# for returned const char*&
- Generate valid C# for overloads with types nested in templates
- Fix the naming of anonymous types when 2+ types are nested 2+ levels
- Remove ParserOptions.Abi since its misleading as it serves no purpose
- Improved robustness when parsing C++ ABI kind
## [0.9.1] - 2019-4-13
- Generate valid C# for template indexers taking const char*
- Restore removed specializations
- Add a generic pointer to resolve ambiguity
- Fix a crash when a function pointer is a template arg
- Expose public anonymous types
- Fix the generated C# for fields of type function pointer
- Fix the generated C# for const char*&
- Fix the pass for duplicate names not to compare return parameters
- Fix the generated C# when type arguments are mapped the same
- Fix typo in options: chsarp -> csharp
- Fix #1191 CppSharp.CLI.exe --rtti sets -fno-rtti to clang
- Fix the generated C# for a case with 2 template args
- Fix the generation of properties for locations in expressions
- Added statement visiting to IAstVisitor
- Fix the generated C# when a dependent param has a default value
- Fix ambiguous code when a nested type and a property-like method with overloads have the same name
## [0.9.0] - 2019-3-1
- Extended the AST with C++ statements and expressions.
- Made public the finding of enabled type maps by strings.
- Fixed the renaming of properties with the same name as their owners.
- Simplified the pass for properties.
- Skip ignored bases in `ClassExtensions.GetBaseProperty`.
- Fixed missing options copy in ParserOptions copy constructor.
- Use MSBuild when building LLVM on Windows due to PDB issues with Ninja.
- Improve robustness when parsing types and decls.
- Fixed indentation regressions.
- Deleted useless output.
- Fixed naming edge case in `GenerateProperties.GetReadWritePropertyName`.
- Added `PrintModuleOutputNamespace` option to `CSharpTypePrinter`.
- Fixed extraneous new lines when generating multi-line comments.
- Obsoleted all hand-written types for expressions.
- Use `takeError()` when handling errors in parsing libraries.
- Fixed a crash with `TranslationUnit.FileName` property.
- Added `ForceClangToolchainLookup` option to force to use Clang's toolchain lookup code.
- Extract `ParserOptions` cloning code into a copy constructor.
- Improve `ParserOptions.Verbose` to print compiler arguments.
- Fixed `Options.DryRun` to not generate any binding code.
- Added some helper methods in `Enumeration` to work with scoped enumerations.
- Added a parsing option to skip gathering of native layout info.
- Fixed the generated C# when an instance method has a parameter named "instance".
- Fixed the generated C# for const/non-const overloads with > 1 param.
- Fixed the generated C# when a ref parameter is named after a keyword.
- Fixed the generation for parameters of type void**.
- Fixed the generated C# for indexers in templates specialized with void*.
- Fixed the generated C# for template specializations of pointers.
- Fixed the generated C# for const void*& in parameters.
- Fixed the generated C# when returning a non-const char*.
- Fixed the generated C# for parameters initialized with {}.
- Fixed the generated C# when a template is specialized with T and const T.
- Fixed the generated C# when an unsigned enum is assigned a negative value.
## [0.8.23] - 2019-1-31
- Keep Clang libTooling libs when packaging LLVM.
- Improve error handling in build scripts `UseClang()`.
- Added .NET Core build folder to Git Ignore .
- Initial integration of Clang AST viewer GUI tool.
- Made an exception serializable and removed another.
- Fixed the warnings in the test C++ for C# only.
- Fixed a crash when parsing libraries on macOS.
- Fixed error handling when parsing non-existent libraries.
- Added support for building with Clang and LLD.
- Switched to use csc.exe Roslyn compiler under Mono
- Disable most of the support for explicit pre-C++11 ABI since we do not need it anymore
- Fixed warnings in native test code.
- Fixed the generation of dependent virtual methods.
- Fixed overloading of operators with parameters mapped to the same type.
- Extended the type maps for primitive strings to C++/CLI.
- Handled int and long in maps to help resolve ambiguity.
- Simplified type maps by unlinking them from declarations.
- Properly hashed types to optimize their storage in maps.
- Fixed right-value references creating ambiguous overloads.
- Fixed the generated code in a case of ambiguous overloads.
- Added type maps for primitive strings (pointers to char).
- Added an option for skipping private declarations.
- Tested indirect calls from native code of overrides in the target language.
- Initial support for building under .NET Core.
- Updated the CI on Linux to use GCC 7.
- Exported all additional symbols on macOS.
- Fixed error handling and message when parsing non-existent files.
- Added a test for passing an std::string by value.
- Fixed the marshalling of std::string with GCC 6+ on Linux.
- Added a type map for char.
- Make Windows10SDK detection more robust
- Cached found type maps for faster look-ups.
- Deleted unused and slow code.
- Fixed the parsing of functions with integral template args.
- Decreased the build time on the Linux CI.
- Fixed a crash when parsing type aliases.
- Fixed the build of the parser when its path has spaces.
- Changed type maps to only return types - no strings.
- Simplified type maps by using static objects to disable as needed.
- Optimized the walking of the managed AST.
- Optimized the generation of C# by not splitting any strings.
- Optimized the walking of the AST by simplifying its search.
- Fixed the late parsing of templates.
- Fixed LLVM/Clang tar.gz archive extraction using 7-Zip on Windows.
- Fixed Windows SDK version detection in build scripts.
- Resolved ambiguity between char-like types in the generated C#.
- Fixed the generated C# for templates with > 1 ctor taking a pointer to a class.
- Fixed the generated C# for pure virtual functions with default arguments.
- Fixed the generated C# for default arguments of type pointer to a function.
- Fixed the generated C# for a certain case of two default parameters.
- Fixed the generated C# for arguments with default values of "nullptr".
- Fixed the generated C# for setters with default parameters.
- Fixed the generated C# for public fields with types mapped to primitive.
- Fixed the generated C# for constant references to primitives.
- Upgraded the CI script to use Ubuntu 16.04.
- Fixed ambiguity when the type of a parameter is mapped to a type in an overload.
## [0.8.22] - 2018-9-15
- Fixed renaming when items of an enum only differ by case.
- Fixed the generated C# for destructors of abstract classes.
- Stopped using methods deprecated in recent Clang.
- Excluded many unused modules when building LLVM and Clang.
- Worked around a missing symbol from a template specialization on macOS.
- Updated to LLVM/Clang revisions 339502/339494 respectively.
- Fixed the generation when a secondary base is used in more than one unit.
- Fixed debugger display variable reference in Block class.
## [0.8.21] - 2018-8-1
- Only generated the system module in C# generators.
- Fixed missing save of generated module template to outputs.
- Fixed code generator to generate the system module even in single file per unit mode.
- Silenced verbose duplicate constructor and operator warnings.
- Improved the defaults of necessary generation options to improve accessibility.
- Called the parser setup code in CLI.
- Only included header files when scanning directories in CLI.
## [0.8.20] - 2018-5-22
- Fixed generation support for pointers to enums in C#.
- Fixed a case of functions converted to methods.
- Improve error handling in case of exceptions in CLI tool driver.
- Added an option to the CLI tool for enabling RTTI.
- Improved the messages for errors in the CLI tool.
- Added parameter index to managed marshal variables.
- Changed the generated C# for const references to primitives as just primitives.
- Error messages are now written to stderr.
## [0.8.19] - 2018-1-30
- Added getting of the path to Xcode based on xcode-select.
## [0.8.18] - 2018-1-28
- Do not generate wrappers for template specializations if original method in template class is ignored.
- Add one more include path which Linux usually expects.
- Evaluate expressions for enums generated using GenerateEnumFromMacros
- Evaluate expressions when generating enum from macros - ExpressionEvaluator taken from https://github.com/codingseb/ExpressionEvaluator
- Set the name-space for enums generated from macros.
- Preliminary script for building 32-bit Nuget package
- Field property getter returns non-value types by reference instead of by copy.
- Update VS check when downloading pre-compiled LLVM packages.
- Add `IgnoreConversionToProperty(pattern)` and `ForceConversionToProperty(pattern)`.
- Add `UsePropertyDetectionHeuristics` option to `DriverOptions`.
- Add "run" to verbs.txt
- Added support for 16-bit wide characters (char16_t).
- Fixed the generated C++ for symbols when protected classes need them.
- Removed the possibility for conflicts between overloads when generating C++ for symbols.
## [0.8.17] - 2017-12-25
- Collected extra symbols in the order of their compilation.
- Fixed the generated C# when a specialisation of a template used as a secondary base has an invalid function.
- Fixed the generated C# when a template interface specialised with another specialisation returns a template parameter.
- Fixed the generated C# when a default arg is assigned a specialisation also used as a secondary base.
- Fixed a crash when a constructor takes a template or specialisation.
- Fixed the generated C# for public fields with type a dependent pointer.
- Enabled classes having specializations for secondary bases to call their extensions.
- Fixed the generated C# for subclasses of specialisations used as secondary bases.
- Fixed the generated C# when a template specialization with extensions is used for a secondary base.
- Extended the multiple inheritance to work for templates.
- Fixed a regression causing public fields of type specialization to be ignored.
- Fixed the generated C# for templates with optional arguments.
- Represented "void" with "object" for template arguments in the generated C#.
- Fixed the generated C# for public fields with type a dependent function pointer.
- Fixed the generated C# when a constructor has a default parameter with type an external specialisation.
- Set an index when marshalling the value in setters of properties.
- Fixed the generated C# when a function uses an external specialisation.
- Fixed the generated C# when a base class is an external specialisation.
- Fixed the generated C# for indexers with dependent keys.
- Fixed the generated C# for templated indexers specialised with enums.
- Add compiler/abi information to LLVM package names on linux.
- Exported entire specialisations when they only have valid functions.
- Considered dependent fields when generating internals for types nested in templates.
- Removed extensions for non-generated template specialisations.
- Fixed the generated C# when a template returns a specialisation with itself as a type arg.
- Fixed the generated C# for members of types nested in templates.
- Fixed the generated C# when a template is nested in another.
- Add ability for managed module wrapper to reference extra assemblies.
- Re-added linux include path that was removed by mistake.
- Enable debug information generation for all tests.
- Fix debug output not being generated when AST element had no comment.
- Explicitly link to libstdc++ on linux.
- All arguments passed to `build/Compile.sh` are passed to premake. Allows more fine-grained build customization when using this shell script for compiling.
- Tweak linux include dirs, previous change broke GCC7 include dirs on archlinux.
- Consistent class/struct keywords fixed for cases where wrapper class would contain members from several different translation units.
- Fix debug output breaking generated binding code.
- Completely remove `GenerateUnformatted()` method.
- CI: x64 builds on msvc and sudo requirement for travis
- Always generate formatted code.
- Fix `Delegates` name-space being not generated. In some cases `Delegates` name-space could be attached to a name-space which is not wrapped and as a result of that `Delegates` name-space was also not generated in wrapper code resulting in a wrapper build errors. Change adds extra logic which tries to find the correct library name-space if more than one name-space is present.
- Consistently declare classes/structs. Fixes issue where compilation error is produced due to file name containing constants matching class marked as value type.
- Fix linking to LLVM libs on linux, when system has llvm/clang installed.
- Enable cxx11 abi for GCC 4.9+ on linux.
- Worked around a bug in the Mono C# compiler when casting generics.
- Fixed a crash when the body of a templated function contains references to non-functions.
- Use correct LLVM build dir for includes from unpackaged LLVM builds
- get_llvm_build_dir() returns "build" subdir if it exists, if not - subdir with package name.
- Fix linked libs for linux
- Use correct LLVM build dir for includes from unpackaged LLVM builds.
- Removed a duplicate explicit instantiation from the tests.
- Cloning llvm from git replaced with downloading archives of exact commits from github. This is much faster.
- Worked around duplication of types nested in templates and forwarded.
- Fixed a crash when passing null as an std::string on Unix.
- Force-set platform type to managed targets.
- Fix linux include paths in ParserGen and CLI generator.
- Fix build errors in CppSharp.Parser.Bootstrap target.
- Fixed a crash when there are parsing errors.
- Fixed the collection of additional symbols to ignore warnings.
- Fixed the generated C# when a constructor takes a specialisation.
- Fixed a possible crash when instantiating template functions in the parser.
- Fixed the generated C# for templates with fields other templates not used anywhere else.
- Fixed the generated C# when using std::map.
- Fixed the generated C# for specialisations with an ignored specialisation as an arg.
- Fixed the generated C# for specialisations only used as type arguments.
- Removed extensions for internal template specialisations.
- Fixed the parsing of an undeclared template specialisation with an extension method.
- Validated bodies of instantiated template functions.
- Added a new field accessor synth kind.
- Improved IsSynthetized check to handle property setters.
- Improve get base method and property methods to work with generalized declarations.
- Added AssociatedDeclaration to Declaration copy constructor.
- Included template specialisations only used as returned types.
- Included the destructor of std::allocator to the C++ symbols.
- Prevented C++ generation for invalid specialised functions.
- Fixed the generated C# for fixed arrays of Booleans
- Updated to LLVM/Clang revisions 318543/318538 respectively.
- Fixed the script for LLVM to handle paths with spaces.
- Generalized method fields to declaration associations.
- Improved debugging display for declarations.
- Added optional visiting of property accessors.
- CodeGenerator is now an IAstVisitor.
- Cleaned up the additional parser options after parsing headers.
- Fixed the generated C++ for symbols to be compatible with Clang.
- Fixed the generated C# when a type nested in a template is forwarded.
## [0.8.16] - 2017-11-10
- Fixed a crash when parsing unnamed declarations in name-spaces.
## [0.8.15] - 2017-11-7
- Handled any level of nesting when generating internals for specialisations in C#.
- Fixed the generation of internals for template specialisations.
- Ensured symbols for nested template specialisations.
- Fixed the generated C++ for external template specialisations.
- Completed just class template specialisations used in functions.
- Fixed a regression of generating templates in C# with the option off.
- Optimised the parser by skipping the system translation units.
- Reused parameters between functions and their types (as Clang does).
- Added an option for specifying STD types to bind.
- Reduced time and memory during generation by skipping methods of most STD classes.
- Improved the check for a layout on a record.
- Fixed a crash when trying to get a source location for an implicit declaration.
- Fixed the generated C# for a fixed array of pointers.
- Removed unused STD enumerations from generation.
- Fixed a crash when a comment contains regular text wrapped in <>.
- Made only really used classes internal.
- Fixed a typing error in the name of a function.
- Ignored return parameters when fixing default arguments of overrides.
- Ensured no overflown stack in the AST converter.
- Fixed code generation for using template types.
- Improved debugging display for Type type.
- Fixed incorrectly generated bindings for class with non-type template arguments.
- Fixed the generated C# for templates derived from regular dynamic classes.
- Ensured all non-system template specialisations are complete.
- Fixed a problem when walking the managed AST because friend templated classes were seen as declared multiple times and resulted into a crash.
- Improved type notation in the manual.
- Documented string marshaling behavior.
- Fixed implicit class record walking in the parser.
- Added a new verbose flag to the CLI tool and improved verbose handling.
- Fixed duplicate generation of forward declared class.
- Small cleanup and minor optimizations in ResolveIncompleteDeclsPass.
- Improved the fix for handling non-type params in template specialisation types.
- Fixed template parsing issue with processing of type locs.
- Fixed a parser bug when dealing with DependentTemplateSpecializationTypeLoc.
- Fixed an erroneous usage of LLVM cast with a regular C++ type. Only found with debug-mode LLVM build.
- Fixed VS2017 system includes search error #957 (#958)
## [0.8.14] - 2017-9-17
- Added experimental support for templates.
- Fixed the generated C# when a virtual function takes a fixed array.
- Fixed the generated C# for fixed arrays in types of parameters.
- Fixed the generated C# for virtuals taking arrays of objects.
- Lookup Mono SDK path on Windows registry.
- Fixed the generated C# when a virtual function takes an array.
- Fixed the generated C# with 4+ modules and repetitive delegates.
- Added C# marshalling of parameters of type array of const char* const.
- Added C# marshalling of parameters of type array of const char*.
- Fixed null arrays in C# to be passed as such to C/C++.
- Added C# marshalling of parameters of type array of objects.
- Added C# marshalling of parameters of type array of primitives.
- Added marshalling of parameters of type array of pointers.
- Fixed the generated C# for two anonymous types nested in another anonymous type.
- Removed unused internals from the generated C#.
- Added an example for the parser API-s.
- Add C++17 to the parser options
- Compile.sh script now has improved error handling.
- Linux toolchain can be supplied in the same spirit in path probing on Mac.
- Enabled empty arrays of non-primitives only when not using MSVC.
- Ignore zero-sized constant C array types.
- The compilation platform is now nullable by default and validated by the host platforms.
- Added LLVM target initialization and supporting libraries for parsing inline assembly.
- Fixed a crash when trying to use a VS version missing from the system.
- Fixed the binding of multiple identical function pointers with a calling convention.
- Got rid of anonymous names for delegates.
- Fixed the calling conventions of delegates.
- Ensures that if a delegate is used for a virtual as well as something else, it finally ends up as public.
- Fixed the code generation when the return type of a method is a function pointer that has been used somewhere else as well.
- Added Access and Calling convention to the delegate definition.
- Generated properties from setters returning Booleans.
- Added some aliases to options in the CLI tool.
- [generator] Improved processing for C++ inline namespaces.
- Fixed initial output messages in the CLI.
- Generated properties from <type> get()/void get(<type>) pairs.
- Restored the option for generating one C# file per unit.
- Fixed the sorting of modules to also work with manually added dependencies.
- Do not generated unformatted code if debug mode is enabled.
- Added an option to the CLI for enabling debug mode for generated output.
- Improved the directory setup in the CLI in case the path is not a file path.
- Adds a new option to the CLI for automatic compilation of generated code.
- Adds a new dedicated "-exceptions" flag to enable C++ exceptions in the CLI.
- Added a new -A option to the CLI to pass compiler arguments to Clang parser.
- Fixed the name of an option in the CLI.
- Removed the showing of help for the CLI if we have output an error previously.
- Improved error messages in the CLI.
- Improve platform detection in the CLI so the current platform is set by default.
- Fixed a directory check in the CLI that was throwing exceptions in Mono.
- Fixed the generated C# indexers for specialisations of pointers.
- Fixed the generated C# for increment and decrement operators.
- Removed leftovers in the comments from unsupported custom xml tags.
- Fixed the generation of symbols to check all base classes up the chain.
- Printed the text from unsupported comment tags.
- Fixed the generated C# for a case of a typedef of a function pointer.
Typedefs of function pointers can be written in two ways:
typedef void (*typedefedFuncPtr)();
int f(typedefedFuncPtr fptr);
typedef void (typedefedFuncPtr)();
int f(typedefedFuncPtr* fptr);
Up until now we only supported the former.
- Fixed the C# generation for functions with typedefed function pointers as params
- Set the name-space of a parameter to its function.
- Included the comments plain text to the remarks block.
- Fix the typo in LLVM.lua
- Prevented projects from being generated using GenerateProjects.bat
- Fixed the generated C# for setters with a reference to a primitive type.
- Ensured a single element for remarks in the generated XML documentation comments.
- Fixed the renaming of methods in forwarded types from secondary bases in dependencies.
- Added to a method a list of its overridden methods.
- Generated internals of external specialisations only if the template has template fields.
- Equalised the access of overrides and their base methods.
- Fixed the code generation for indexers returning a void pointer.
- Fixed the generated C# when a protected constructor has a parameter with a protected type.
- Fixed the generated C# when an external specialisation with a dependent field is used as a field.
- Made Function a DeclarationContext to match the Clang AST.
- Made the C/C++ language switches adjustable in managed code.
- Added an option to enable or disable RTTI.
- Fixed the generation of inlines to handle types in classes in name-spaces.