Body

INCLUDE FILE

#include "Body/Body.h"

class Body

Represents a body of an object or macro. This is the class other parts of the program interact with. It is a wrapper around the BodyElement hierarchy.

DEFINITION

            class Body;
        

constructor Body

Constructs an empty body.

DEFINITION

Body

(

);

constructor Body

Constructs a body with a given element.

DEFINITION

Body

(

const std::shared_ptr< BodyElement > & element

);

PARAMETER	DESCRIPTION
`element`	The element to wrap.

method append

Appends a new element to the body.

If necessary, the body will be converted to a BlockBody to accommodate the new element.

DEFINITION

void append

(

const Body & element

);

PARAMETER	DESCRIPTION
`element`	The element to append.

method append_sub

DEFINITION

std::pair< bool, std::optional< Body > > append_sub

(

const Body & element

);

PARAMETER	DESCRIPTION
`element`

RETURNS	DESCRIPTION
`std::pair< bool, std::optional< Body > >`

method asconst

Get the body element as a specific type.

DEFINITION

template <typename T>

T * as

(

) const;

RETURNS	DESCRIPTION
`T *`	The body element as type T, or nullptr if it is not of that type.

method backconst

DEFINITION

std::optional< Body > back

(

) const;

RETURNS	DESCRIPTION
`std::optional< Body >`

method cloneconst

Create a deep copy of the body.

DEFINITION

Body clone

(

const CloneContext & context

) const;

PARAMETER	DESCRIPTION
`context`

RETURNS	DESCRIPTION
`Body`	A new Body that is a deep copy of this body.

method emptyconst

Check if it is an EmptyBody.

DEFINITION

bool empty

(

) const;

RETURNS	DESCRIPTION
`bool`	`true` if the body is empty, `false` otherwise.

method encode

DEFINITION

void encode	(	std::string & bytes,
		const Memory * memory = nullptr	);

PARAMETER	DESCRIPTION
`bytes`
`memory`

method enter_names

DEFINITION

void enter_names	(	Scope * scope,
		Entity * containing_entity	);

PARAMETER	DESCRIPTION
`scope`
`containing_entity`

method evaluate

DEFINITION

void evaluate

(

const EvaluationContext & context

);

PARAMETER	DESCRIPTION
`context`

method evaluatedconst

DEFINITION

std::optional< Body > evaluated

(

const EvaluationContext & context

) const;

PARAMETER	DESCRIPTION
`context`

RETURNS	DESCRIPTION
`std::optional< Body >`

method expand_calls

Expand macro and function calls in the body.

This will recursively expand all macro and function calls within the body.

DEFINITION

void expand_calls

(

);

method fully_evaluated

Check if all contained body elements and expressions have been fully evaluated.

DEFINITION

bool fully_evaluated

(

);

RETURNS	DESCRIPTION
`bool`	`true` if the body is fully evaluated, `false` otherwise.

method get_elementconst

Get the body element.

DEFINITION

std::shared_ptr< BodyElement > get_element

(

) const;

RETURNS	DESCRIPTION
`std::shared_ptr< BodyElement >`	The body element as a shared pointer.

method isconst

Check if the body element is of a specific type.

DEFINITION

template <typename T>

bool is

(

) const;

RETURNS	DESCRIPTION
`bool`	`true` if the body element is of type T, `false` otherwise.

method offsetconst

DEFINITION

SizeRange offset

(

) const;

RETURNS	DESCRIPTION
`SizeRange`

method resolve

Resolve all names in the body.

DEFINITION

void resolve	(	Scope * scope,
		Entity * containing_entity	);

PARAMETER	DESCRIPTION
`scope`	The scope to resolve names in.
`containing_entity`	The entity that contains the body.

method serializeconst

DEFINITION

void serialize	(	std::ostream & stream,
		const std::string & prefix = ""	) const;

PARAMETER	DESCRIPTION
`stream`
`prefix`

method sizeconst

DEFINITION

std::optional< uint64_t > size

(

) const;

RETURNS	DESCRIPTION
`std::optional< uint64_t >`

method size_rangeconst

DEFINITION

SizeRange size_range

(

) const;

RETURNS	DESCRIPTION
`SizeRange`

method type_nameconst

DEFINITION

std::string_view type_name

(

) const;

RETURNS	DESCRIPTION
`std::string_view`

method validconst

DEFINITION

bool valid

(

) const;

RETURNS	DESCRIPTION
`bool`

member elementprivate

DEFINITION

std::shared_ptr< BodyElement > element;