v0.6.0

News

• Updated LLVM to version 14

• Build release packages with github runners Windows-2022

• Add support for passsing C++ version to underlying clang tool

v0.5.6

News

• Changes to how the dependency is calculated. Now it's simply the order of the ID's in IR
  • Previously Parser returned a vector of the order of objects to be initiated. This is now embedded in the id

v0.5.5

News

Updated to use IR v0.15.1 where static qualifier is moved from types to variables.
Meaning global/member variables now own the static qualifiers

Add a check that now makes it understand const&/* qualified templates.
Before it would not parse the template arguments of those types.
(meaning std::vector<double> const& did not get correctly parsed for instance)

Add tests for all of the above

Move to MacOS 11

v0.5.4

News

Better algorithm when solving dependencies between objects.

This was suggested by reddit user u/sQGNXXnkceeEfhm

O(V^2) -> O(V + E) where V is the number of objects,
and E is the number of connections between them.

v0.5.3

News

Features

Code quality

• Better use of #include <algorithms> after writing blog post.

v0.5.2

News

Features

Fixes

• Fixed a bug related to dependency management between types

v0.5.1

News

Features

Fixes

• Fixed a bug related to dependency management between types

v0.5.0

News

Features

• Now also returns a MetaData object
  • Contains the order that objects have to be defined

See example:

struct Data {
	enum class Inner { I0, I1 };
};

Data::Inner f();

In this case f requires Inner which requires Data. Previously this was up to the user to figure out.

• Supports IR id property for classes, variables and enums

Fixes

• Fixed a bug related to creating multiple records for forward declarations.

• No longer prints clang warnings

v0.4.1

News

Features

• Support for more operators

The following operators are now parsed:

struct Operator {
  // +-*/&
  Operator operator+(int);
  Operator operator-(int);
  Operator operator*(int);
  Operator operator/(int);
  Operator operator%(int);

  // Assignment
  Operator& operator=(Operator&& other);
  Operator& operator+=(Operator&& other);
  Operator& operator-=(Operator&& other);
  Operator& operator*=(Operator&& other);
  Operator& operator/=(Operator&& other);
  Operator& operator%=(Operator&& other);

  // {in,de}crement
  Operator& operator++();
  Operator& operator--();

  // Shift
  Operator operator<<(const Operator& other);
  Operator operator>>(const Operator& other);

  // Comparisons
  bool operator==(const Operator& rhs);
  bool operator!=(const Operator& rhs);
  bool operator< (const Operator& rhs);
  bool operator> (const Operator& rhs);
  bool operator<=(const Operator& rhs);
  bool operator>=(const Operator& rhs);

  // Subscript
  Operator& operator[](unsigned idx);

  // Call
  double operator()(double x);
};

• Add support for parsing {pure,} virtual functions

v0.4.0

News

Features

• Added support for parsing documentation on namespace

  • Same as functions, classes etc.
  • Added tests for all supported documentation strings

• Added support for parsing out inheritence.

  • Fully qualified name of class that gets inherited from (one for each of public, private, protected)
  • Added tests

• Add support for basic operators

Unsupported operators now result in an error. Previously this was not handled and passed as a normal function, leading to strange behaviour further down the line.

The following operators are supported:

struct Operator {
  // +-*/&
  Operator operator+(int);
  Operator operator-(int);
  Operator operator*(int);
  Operator operator/(int);
  Operator operator%(int);

  // Assignment
  Operator& operator=(Operator&& other) noexcept;

  // Comparisons
  bool operator==(const Operator& rhs);
  bool operator!=(const Operator& rhs);
  bool operator< (const Operator& rhs);
  bool operator> (const Operator& rhs);
  bool operator<=(const Operator& rhs);
  bool operator>=(const Operator& rhs);

  // Subscript
  Operator& operator[](unsigned idx);

  // Call
  double operator()(double x);
};