AstNode Struct Reference

#include <ast.h>

Collaboration diagram for AstNode:

Public Attributes
NodeType	type
size_t	line
size_t	column
NodeCategory	category
union {
struct {
union {
struct {
char *   name
char *   doc_comment
int   potions
AstNode **   body
size_t   body_count
const char *   file_path
Token *   tokens
size_t   token_count
void *   scope
}   module
struct {
const char *   module_name
const char *   alias
}   use
struct {
char **   platforms
AstNode **   bodies
size_t   arm_count
bool   has_default
AstNode *   default_body
}   os
struct {
const char *   lib_name
}   link
}
}   preprocessor
struct {
union {
struct {
LiteralType   lit_type
union {
long long   int_val
double   float_val
char *   string_val
char   char_val
bool   bool_val
}   value
}   literal
struct {
char *   name
}   identifier
struct {
BinaryOp   op
AstNode *   left
AstNode *   right
}   binary
struct {
UnaryOp   op
AstNode *   operand
}   unary
struct {
AstNode *   callee
AstNode **   args
size_t   arg_count
}   call
struct {
AstNode *   target
AstNode *   value
}   assignment
struct {
AstNode *   condition
AstNode *   then_expr
AstNode *   else_expr
}   ternary
struct {
bool   is_compiletime
AstNode *   object
char *   member
}   member
struct {
AstNode *   object
AstNode *   index
}   index
struct {
AstNode *   expr
}   grouping
struct {
AstNode **   elements
size_t   element_count
size_t   target_size
}   array
struct {
AstNode *   object
}   deref
struct {
AstNode *   object
}   addr
struct {
AstNode *   size
}   alloc
struct {
AstNode *   to
AstNode *   from
AstNode *   size
}   memcpy
struct {
AstNode *   ptr
}   free
struct {
AstNode *   type
AstNode *   castee
}   cast
struct {
AstNode *   type
AstNode *   msg
}   input
struct {
AstNode *   command
}   _system
struct {
AstNode **   args
size_t   count
}   syscall
struct {
AstNode *   object
bool   is_type
}   size_of
struct {
char *   name
char **   field_names
AstNode **   field_value
size_t   field_count
}   struct_expr
struct {
AstNode *   expr
}   spread
}
}   expr
struct {
union {
struct {
AstNode **   modules
size_t   module_count
}   program
struct {
AstNode *   expression
}   expr_stmt
struct {
const char *   name
char *   doc_comment
AstNode *   var_type
AstNode *   initializer
bool   is_mutable
bool   is_public
}   var_decl
struct {
const char *   name
char *   doc_comment
AstNode **   public_members
size_t   public_count
AstNode **   private_members
size_t   private_count
bool   is_public
}   struct_decl
struct {
const char *   name
char *   doc_comment
AstNode *   type
AstNode *   function
bool   is_public
bool   is_static
}   field_decl
struct {
AstNode *   type
bool   via_pointer
bool   is_public
}   spread_decl
struct {
const char *   name
char *   doc_comment
char **   members
size_t   member_count
bool   is_public
}   enum_decl
struct {
const char *   name
char *   doc_comment
char **   param_names
AstNode **   param_types
size_t   param_count
AstNode *   return_type
bool   is_public
bool   is_static
AstNode *   body
bool   returns_ownership
bool   takes_ownership
bool   forward_declared
void *   scope
bool   is_dll_import
const char *   dll_name
const char *   dll_callconv
bool   is_lib_import
const char *   lib_name
}   func_decl
struct {
AstNode *   condition
AstNode *   then_stmt
AstNode **   elif_stmts
int   elif_count
AstNode *   else_stmt
void *   scope
void *   then_scope
void *   else_scope
}   if_stmt
struct {
AstNode *   condition
AstNode *   optional
AstNode *   body
AstNode **   initializer
size_t   init_count
void *   scope
}   loop_stmt
struct {
AstNode *   value
}   return_stmt
struct {
AstNode **   statements
size_t   stmt_count
void *   scope
}   block
struct {
AstNode **   expressions
size_t   expr_count
bool   ln
}   print_stmt
struct {
bool   is_continue
}   break_continue
struct {
AstNode *   statement
}   defer_stmt
struct {
AstNode *   condition
struct AstNode **   cases
size_t   case_count
struct AstNode *   default_case
void *   scope
}   switch_stmt
struct {
char **   function_name_list
AstNode **   function_type_list
char **   struct_name_list
size_t   function_name_count
size_t   struct_name_count
AstNode *   body
}   impl_stmt
struct {
AstNode **   values
size_t   value_count
AstNode *   body
}   case_clause
struct {
AstNode *   body
}   default_clause
}
}   stmt
struct {
union {
struct {
const char *   name
}   basic
struct {
AstNode *   pointee_type
}   pointer
struct {
AstNode *   element_type
AstNode *   size
}   array
struct {
AstNode **   param_types
size_t   param_count
AstNode *   return_type
}   function
struct {
char **   parts
size_t   part_count
}   resolution
struct {
const char *   name
AstNode **   member_types
const char **   member_names
size_t   member_count
}   struct_type
}
}   type_data
};

Member Data Documentation

[union]

union { ... } AstNode

[struct]

struct { ... } AstNode::_system

[struct]

struct { ... } AstNode::addr

alias

const char* AstNode::alias

[struct]

struct { ... } AstNode::alloc

arg_count

size_t AstNode::arg_count

args

AstNode** AstNode::args

arm_count

size_t AstNode::arm_count

[struct] [1/2]

struct { ... } AstNode::array

[struct] [2/2]

struct { ... } AstNode::array

[struct]

struct { ... } AstNode::assignment

[struct]

struct { ... } AstNode::basic

[struct]

struct { ... } AstNode::binary

[struct]

struct { ... } AstNode::block

bodies

AstNode** AstNode::bodies

body [1/2]

AstNode** AstNode::body

body [2/2]

AstNode* AstNode::body

body_count

size_t AstNode::body_count

bool_val

bool AstNode::bool_val

[struct]

struct { ... } AstNode::break_continue

[struct]

struct { ... } AstNode::call

callee

AstNode* AstNode::callee

[struct]

struct { ... } AstNode::case_clause

case_count

size_t AstNode::case_count

cases

struct AstNode** AstNode::cases

[struct]

struct { ... } AstNode::cast

castee

AstNode* AstNode::castee

category

NodeCategory AstNode::category

char_val

char AstNode::char_val

column

size_t AstNode::column

command

AstNode* AstNode::command

condition

AstNode* AstNode::condition

count

size_t AstNode::count

default_body

AstNode* AstNode::default_body

default_case

struct AstNode* AstNode::default_case

[struct]

struct { ... } AstNode::default_clause

[struct]

struct { ... } AstNode::defer_stmt

[struct]

struct { ... } AstNode::deref

dll_callconv

const char* AstNode::dll_callconv

dll_name

const char* AstNode::dll_name

doc_comment

char* AstNode::doc_comment

element_count

size_t AstNode::element_count

element_type

AstNode* AstNode::element_type

elements

AstNode** AstNode::elements

elif_count

int AstNode::elif_count

elif_stmts

AstNode** AstNode::elif_stmts

else_expr

AstNode* AstNode::else_expr

else_scope

void* AstNode::else_scope

else_stmt

AstNode* AstNode::else_stmt

[struct]

struct { ... } AstNode::enum_decl

expr [1/2]

AstNode* AstNode::expr

[struct] [2/2]

struct { ... } AstNode::expr

expr_count

size_t AstNode::expr_count

[struct]

struct { ... } AstNode::expr_stmt

expression

AstNode* AstNode::expression

expressions

AstNode** AstNode::expressions

field_count

size_t AstNode::field_count

[struct]

struct { ... } AstNode::field_decl

field_names

char** AstNode::field_names

field_value

AstNode** AstNode::field_value

file_path

const char* AstNode::file_path

float_val

double AstNode::float_val

forward_declared

bool AstNode::forward_declared

[struct]

struct { ... } AstNode::free

from

AstNode* AstNode::from

[struct]

struct { ... } AstNode::func_decl

function [1/2]

AstNode* AstNode::function

[struct] [2/2]

struct { ... } AstNode::function

function_name_count

size_t AstNode::function_name_count

function_name_list

char** AstNode::function_name_list

function_type_list

AstNode** AstNode::function_type_list

[struct]

struct { ... } AstNode::grouping

has_default

bool AstNode::has_default

[struct]

struct { ... } AstNode::identifier

[struct]

struct { ... } AstNode::if_stmt

[struct]

struct { ... } AstNode::impl_stmt

index [1/2]

AstNode* AstNode::index

[struct] [2/2]

struct { ... } AstNode::index

init_count

size_t AstNode::init_count

initializer [1/2]

AstNode* AstNode::initializer

initializer [2/2]

AstNode** AstNode::initializer

[struct]

struct { ... } AstNode::input

int_val

long long AstNode::int_val

is_compiletime

bool AstNode::is_compiletime

is_continue

bool AstNode::is_continue

is_dll_import

bool AstNode::is_dll_import

is_lib_import

bool AstNode::is_lib_import

is_mutable

bool AstNode::is_mutable

is_public

bool AstNode::is_public

is_static

bool AstNode::is_static

is_type

bool AstNode::is_type

left

AstNode* AstNode::left

lib_name

const char* AstNode::lib_name

line

size_t AstNode::line

[struct]

struct { ... } AstNode::link

lit_type

LiteralType AstNode::lit_type

[struct]

struct { ... } AstNode::literal

ln

bool AstNode::ln

[struct]

struct { ... } AstNode::loop_stmt

member [1/2]

char* AstNode::member

[struct] [2/2]

struct { ... } AstNode::member

member_count

size_t AstNode::member_count

member_names

const char** AstNode::member_names

member_types

AstNode** AstNode::member_types

members

char** AstNode::members

[struct]

struct { ... } AstNode::memcpy

[struct]

struct { ... } AstNode::module

module_count

size_t AstNode::module_count

module_name

const char* AstNode::module_name

modules

AstNode** AstNode::modules

msg

AstNode* AstNode::msg

name [1/2]

char* AstNode::name

name [2/2]

const char* AstNode::name

object

AstNode* AstNode::object

op [1/2]

BinaryOp AstNode::op

op [2/2]

UnaryOp AstNode::op

operand

AstNode* AstNode::operand

optional

AstNode* AstNode::optional

[struct]

struct { ... } AstNode::os

param_count

size_t AstNode::param_count

param_names

char** AstNode::param_names

param_types

AstNode** AstNode::param_types

part_count

size_t AstNode::part_count

parts

char** AstNode::parts

platforms

char** AstNode::platforms

pointee_type

AstNode* AstNode::pointee_type

[struct]

struct { ... } AstNode::pointer

potions

int AstNode::potions

[struct]

struct { ... } AstNode::preprocessor

[struct]

struct { ... } AstNode::print_stmt

private_count

size_t AstNode::private_count

private_members

AstNode** AstNode::private_members

[struct]

struct { ... } AstNode::program

ptr

AstNode* AstNode::ptr

public_count

size_t AstNode::public_count

public_members

AstNode** AstNode::public_members

[struct]

struct { ... } AstNode::resolution

[struct]

struct { ... } AstNode::return_stmt

return_type

AstNode* AstNode::return_type

returns_ownership

bool AstNode::returns_ownership

right

AstNode* AstNode::right

scope

void* AstNode::scope

size

AstNode* AstNode::size

[struct]

struct { ... } AstNode::size_of

[struct]

struct { ... } AstNode::spread

[struct]

struct { ... } AstNode::spread_decl

statement

AstNode* AstNode::statement

statements

AstNode** AstNode::statements

[struct]

struct { ... } AstNode::stmt

stmt_count

size_t AstNode::stmt_count

string_val

char* AstNode::string_val

[struct]

struct { ... } AstNode::struct_decl

[struct]

struct { ... } AstNode::struct_expr

struct_name_count

size_t AstNode::struct_name_count

struct_name_list

char** AstNode::struct_name_list

[struct]

struct { ... } AstNode::struct_type

[struct]

struct { ... } AstNode::switch_stmt

[struct]

struct { ... } AstNode::syscall

takes_ownership

bool AstNode::takes_ownership

target

AstNode* AstNode::target

target_size

size_t AstNode::target_size

[struct]

struct { ... } AstNode::ternary

then_expr

AstNode* AstNode::then_expr

then_scope

void* AstNode::then_scope

then_stmt

AstNode* AstNode::then_stmt

to

AstNode* AstNode::to

token_count

size_t AstNode::token_count

tokens

Token* AstNode::tokens

type [1/2]

NodeType AstNode::type

type [2/2]

AstNode* AstNode::type

[struct]

struct { ... } AstNode::type_data

[struct]

struct { ... } AstNode::unary

[struct]

struct { ... } AstNode::use

[union] [1/2]

union { ... } AstNode::value

value [2/2]

AstNode* AstNode::value

value_count

size_t AstNode::value_count

values

AstNode** AstNode::values

[struct]

struct { ... } AstNode::var_decl

var_type

AstNode* AstNode::var_type

via_pointer

bool AstNode::via_pointer

---

The documentation for this struct was generated from the following file:

• src/ast/ast.h