cpy_ast.h File Reference

copy ast nodes More...

Go to the source code of this file.

Functions
ANN Exp *	cpy_exp (MemPool, const Exp *)
ANN Array_Sub	cpy_array_sub (MemPool, const Array_Sub)
ANN ArgList *	cpy_arg_list (MemPool, const ArgList *)
ANN SpecializedList *	cpy_specialized_list (MemPool, const SpecializedList *)
ANN Type_Decl *	cpy_type_decl (MemPool, const Type_Decl *)
ANN VariableList *	cpy_variable_list (MemPool, const VariableList *)
ANN Func_Def	cpy_func_def (MemPool, const Func_Def)
ANN struct Func_Base_ *	cpy_func_base (MemPool, const struct Func_Base_ *)
ANN Class_Def	cpy_class_def (MemPool, const Class_Def)
ANN Extend_Def	cpy_extend_def (MemPool, const Extend_Def)
ANN Fptr_Def	cpy_fptr_def (MemPool p, const Fptr_Def src)
ANN Union_Def	cpy_union_def (MemPool, const Union_Def)
ANN TmplArgList *	cpy_tmplarg_list (MemPool p, const TmplArgList *src)
ANN TagList *	cpy_taglist (MemPool p, const TagList *src)
ANN Tmpl *	cpy_tmpl (MemPool p, const Tmpl *src)
ANN Ast	cpy_ast (MemPool p, const Ast src)
ANN Stmt *	cpy_stmt3 (MemPool p, const Stmt *)

Detailed Description

copy ast nodes

Definition in file cpy_ast.h.

Function Documentation

cpy_arg_list()

ANN ArgList * cpy_arg_list	(	MemPool	p,
		const ArgList *	src )

Definition at line 106 of file ast_cpy.c.

                                                         {
  ArgList *arg = new_arglist(p, src->len);
  for(m_uint i = 0; i < src->len; i++) {
    const Arg _src = arglist_at(src, i);
    Arg *_arg = arglist_ptr_at(arg, i);
    cpy_variable(p, &_arg->var, &_src.var);
    if (_src.exp) _arg->exp = cpy_exp(p, _src.exp);
  }
  return arg;
}

cpy_array_sub()

ANN Array_Sub cpy_array_sub	(	MemPool	p,
		const Array_Sub	src )

Definition at line 26 of file ast_cpy.c.

                                                            {
  Array_Sub a = mp_calloc(p, Array_Sub);
  if (src->exp) a->exp = cpy_exp(p, src->exp);
  a->depth = src->depth;
  return a;
}

cpy_ast()

ANN Ast cpy_ast	(	MemPool	p,
		const Ast	src )

Definition at line 642 of file ast_cpy.c.

                                    {
  Ast a = new_sectionlist(p, src->len);
  for(m_uint i = 0; i < src->len; i++) {
    Section * asec = sectionlist_ptr_at(a, i);
    const Section ssec = sectionlist_at(src, i);
    cpy_section(p, asec, &ssec);
  }
  return a;
}

cpy_class_def()

ANN Class_Def cpy_class_def	(	MemPool	p,
		const Class_Def	src )

Definition at line 632 of file ast_cpy.c.

                                                            {
  Class_Def a = mp_calloc(p, Class_Def);
  cpy_type_def2(p, &a->base, &src->base);
  if (src->body) a->body = cpy_ast(p, src->body);
  if (src->traits) a->traits = cpy_taglist(p, src->traits);
  a->flag  = src->flag;
  a->cflag = src->cflag;
  return a;
}

cpy_exp()

ANN Exp * cpy_exp	(	MemPool	p,
		const Exp *	src )

Definition at line 225 of file ast_cpy.c.

                                            {
  Exp* a = mp_calloc2(p, sizeof(Exp));
  if (src->next) a->next = cpy_exp(p, src->next);
  switch (src->exp_type) {
  case ae_exp_post: // !! naming
    cpy_exp_postfix(p, &a->d.exp_post, &src->d.exp_post);
    break;
  case ae_exp_primary:
    cpy_prim(p, &a->d.prim, &src->d.prim);
    break;
  case ae_exp_decl:
    cpy_exp_decl(p, &a->d.exp_decl, &src->d.exp_decl);
    break;
  case ae_exp_unary:
    cpy_exp_unary(p, &a->d.exp_unary, &src->d.exp_unary);
    break;
  case ae_exp_binary:
    cpy_exp_binary(p, &a->d.exp_binary, &src->d.exp_binary);
    break;
  case ae_exp_cast:
    cpy_exp_cast(p, &a->d.exp_cast, &src->d.exp_cast);
    break;
  case ae_exp_call:
    cpy_exp_call(p, &a->d.exp_call, &src->d.exp_call);
    break;
  case ae_exp_if:
    cpy_exp_if(p, &a->d.exp_if, &src->d.exp_if);
    break;
  case ae_exp_dot:
    cpy_exp_dot(p, &a->d.exp_dot, &src->d.exp_dot);
    break;
  case ae_exp_array:
    cpy_exp_array(p, &a->d.exp_array, &src->d.exp_array);
    break;
  case ae_exp_slice:
    cpy_exp_slice(p, &a->d.exp_slice, &src->d.exp_slice);
    break;
  case ae_exp_lambda:
    cpy_exp_lambda(p, &a->d.exp_lambda, &src->d.exp_lambda);
    break;
  case ae_exp_td:
    a->d.exp_td = cpy_type_decl(p, src->d.exp_td);
    break;
  case ae_exp_named:
    a->d.exp_named.exp = cpy_exp(p, src->d.exp_named.exp);
  }
  a->exp_type = src->exp_type;
  a->emit_var = src->emit_var;
  //  a->meta = src->meta;// maybe meta shoyuld be set as in constructors
  a->loc = src->loc;
  return a;
}

cpy_extend_def()

ANN Extend_Def cpy_extend_def	(	MemPool	p,
		const Extend_Def	src )

Definition at line 625 of file ast_cpy.c.

                                                               {
  Extend_Def a = mp_calloc(p, Extend_Def);
  a->traits = cpy_taglist(p, src->traits);
  a->td = cpy_type_decl(p, src->td);
  return a;
}

cpy_fptr_def()

ANN Fptr_Def cpy_fptr_def	(	MemPool	p,
		const Fptr_Def	src )

Definition at line 396 of file ast_cpy.c.

                                                           {
  Fptr_Def a = mp_calloc(p, Fptr_Def);
  a->base    = cpy_func_base(p, src->base);
  return a;
}

cpy_func_base()

ANN struct Func_Base_ * cpy_func_base	(	MemPool	,
		const struct Func_Base_ *	)

cpy_func_def()

ANN Func_Def cpy_func_def	(	MemPool	p,
		const Func_Def	src )

Definition at line 545 of file ast_cpy.c.

                                                         {
  Func_Def a = mp_calloc(p, Func_Def);
  a->base    = cpy_func_base(p, src->base);
  if (src->d.code) {
    if(!src->builtin && src->d.code) a->d.code = cpy_stmt_list(p, src->d.code);
    else a->d.dl_func_ptr = src->d.dl_func_ptr;
  }
  if (src->captures) a->captures = cpy_captures(p, src->captures);
  //  a->trait = src->trait;
  a->builtin = src->builtin;
  return a;
}

cpy_specialized_list()

ANN SpecializedList * cpy_specialized_list	(	MemPool	p,
		const SpecializedList *	src )

Definition at line 72 of file ast_cpy.c.

                                                                                 {
  SpecializedList *tgt = new_specializedlist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    const Specialized _src = specializedlist_at(src, i);
    Specialized *_tgt = specializedlist_ptr_at(tgt, i);
    _tgt->tag = _src.tag;
    if (_src.td) _tgt->td = cpy_type_decl(p, _src.td);
    if (_src.traits) _tgt->traits = cpy_taglist(p, _src.traits);
  }
  return tgt;
}

cpy_stmt3()

ANN Stmt * cpy_stmt3	(	MemPool	p,
		const Stmt *	src )

Definition at line 440 of file ast_cpy.c.

                                                {
  Stmt* a = mp_calloc2(p, sizeof(Stmt));
  memcpy(a, src, sizeof(Stmt));
  return a;
}

cpy_taglist()

ANN TagList * cpy_taglist	(	MemPool	p,
		const TagList *	src )

Definition at line 63 of file ast_cpy.c.

                                                        {
  TagList *a = new_taglist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    const Tag tag = taglist_at(src, i);
    taglist_set(a, i, tag);
  }
  return a;
}

cpy_tmpl()

ANN Tmpl * cpy_tmpl	(	MemPool	p,
		const Tmpl *	src )

Definition at line 155 of file ast_cpy.c.

                                               {
  Tmpl *a = mp_calloc(p, Tmpl);
  if (!src->call)
    a->list = cpy_specialized_list(p, src->list);
  else {
    a->list = src->list;
    a->call = cpy_tmplarg_list(p, src->call);
  }
  return a;
}

cpy_tmplarg_list()

ANN TmplArgList * cpy_tmplarg_list	(	MemPool	p,
		const TmplArgList *	src )

Definition at line 91 of file ast_cpy.c.

                                                                     {
  TmplArgList *a = new_tmplarglist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    const TmplArg _src = tmplarglist_at(src, i);
    TmplArg *_tgt = tmplarglist_ptr_at(a, i);
    cpy_tmplarg(p, &_src, _tgt);
  }
  return a;
}

cpy_type_decl()

ANN Type_Decl * cpy_type_decl	(	MemPool	p,
		const Type_Decl *	src )

Definition at line 50 of file ast_cpy.c.

                                                              {
  Type_Decl *a = mp_calloc(p, Type_Decl);
  a->tag       = src->tag;
  if (src->array) a->array = cpy_array_sub(p, src->array); // 1
  if (src->types) a->types = cpy_tmplarg_list(p, src->types); // 1
  a->flag = src->flag; // 1
  if (src->next) a->next = cpy_type_decl(p, src->next);
  if (src->fptr) a->fptr = cpy_fptr_def(p, src->fptr);
  a->option = src->option;
  a->ref    = src->ref;
  return a;
}

cpy_union_def()

ANN Union_Def cpy_union_def	(	MemPool	p,
		const Union_Def	src )

Definition at line 425 of file ast_cpy.c.

                                                            {
  Union_Def a = mp_calloc(p, Union_Def);
  a->tag = src->tag;
  a->l        = cpy_variable_list(p, src->l);
  if (src->tmpl) a->tmpl = cpy_tmpl(p, src->tmpl);
  a->flag = src->flag;
  return a;
}

cpy_variable_list()

ANN VariableList * cpy_variable_list	(	MemPool	p,
		const VariableList *	src )

Definition at line 415 of file ast_cpy.c.

                                                                        {
  VariableList *a = new_variablelist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    const Variable _src = variablelist_at(src, i);
    Variable *_tgt = variablelist_ptr_at(a, i);
    cpy_variable(p, _tgt, &_src);
  }
  return a;
}