#include "parser.h"
#include "lexer.h"
#include "builtin.h"
#include "system.h"
#include "term.h"
#include "context.h"

Include dependency graph for parser.cpp:

Macros
#define	MAKE_TYPE(type_name) {type_name, Term::Create(TermID::TYPE, type_name)}

#define	DEFINE_CASE(name, _)

Functions
	__attribute__ ((weak)) TermPtr new lang

Variables
static const std::map< const std::string, const TermPtr >	default_types

static const TermPtr	type_default_none = default_types.find(":None")->second

static const TermPtr	type_default_any = default_types.find(":Any")->second

static const TermPtr	term_none = Term::Create(TermID::NAME, "_", parser::token_type::NAME)

static const TermPtr	term_ellipsys = Term::Create(TermID::ELLIPSIS, "...", parser::token_type::ELLIPSIS)

static const TermPtr	term_required = Term::Create(TermID::NONE, "_", parser::token_type::END)

static const ObjPtr	obj_none = Obj::CreateNone()

static const Variable	var_none = Variable(obj_none)

static const ObjPtr	obj_ellipsys = Obj::CreateType(ObjType::Ellipsis, ObjType::Ellipsis, true)

static const VariablePtr	var_ellipsys = std::make_shared<Variable>(obj_ellipsys)

static const VariablePair	var_none_pair = VariablePair{term_none, var_none}

Macro Definition Documentation

◆ MAKE_TYPE

#define MAKE_TYPE ( type_name ) {type_name, Term::Create(TermID::TYPE, type_name)}

Definition at line 981 of file parser.cpp.

◆ DEFINE_CASE

#define DEFINE_CASE	(		name,
			_ )

Value:

    else if (type.compare(":"#name) == 0) {     \
        return ObjType:: name;                  \
    }

Function Documentation

◆ attribute()

__attribute__ ( (weak) )

new

Definition at line 151 of file parser.cpp.

Variable Documentation

◆ default_types

const std::map<const std::string, const TermPtr> default_types

static

Initial value:

{
     {":None", Term::Create(TermID::TYPE, ":None")} ,
 
     {":Bool", Term::Create(TermID::TYPE, ":Bool")} ,
     {":Int8", Term::Create(TermID::TYPE, ":Int8")} ,
     {":Int16", Term::Create(TermID::TYPE, ":Int16")} ,
     {":Int32", Term::Create(TermID::TYPE, ":Int32")} ,
     {":Int64", Term::Create(TermID::TYPE, ":Int64")} ,
 
     {":Float16", Term::Create(TermID::TYPE, ":Float16")} ,
     {":Float32", Term::Create(TermID::TYPE, ":Float32")} ,
     {":Float64", Term::Create(TermID::TYPE, ":Float64")} ,
 
     {":Complex16", Term::Create(TermID::TYPE, ":Complex16")} ,
     {":Complex32", Term::Create(TermID::TYPE, ":Complex32")} ,
     {":Complex64", Term::Create(TermID::TYPE, ":Complex64")} ,
 
     {":Rational", Term::Create(TermID::TYPE, ":Rational")} ,
 
     {":StrChar", Term::Create(TermID::TYPE, ":StrChar")} ,
     {":StrWide", Term::Create(TermID::TYPE, ":StrWide")} ,
 
     {":Range", Term::Create(TermID::TYPE, ":Range")} ,
     {":Iterator", Term::Create(TermID::TYPE, ":Iterator")} ,
 
     {":Dictionary", Term::Create(TermID::TYPE, ":Dictionary")} ,
 
     {":Any", Term::Create(TermID::TYPE, ":Any")} }