ast_cpy.c File Reference

#include "gwion_util.h"
#include "gwion_ast.h"

Go to the source code of this file.

Functions
ANN Stmt *	cpy_stmt (MemPool p, const Stmt *src)
static ANN void	cpy_stmt2 (MemPool p, Stmt *a, const Stmt *src)
ANN Exp *	cpy_exp (MemPool p, const Exp *src)
ANN TmplArgList *	cpy_tmplarg_list (MemPool p, const TmplArgList *src)
ANN ArgList *	cpy_arg_list (MemPool p, const ArgList *src)
ANN Class_Def	cpy_class_def (MemPool p, const Class_Def src)
static ANN StmtList *	cpy_stmt_list (MemPool p, const StmtList *src)
static ANN void	cpy_var_decl (MemPool p NUSED, Var_Decl *a, const Var_Decl *src)
static ANN void	cpy_exp_dot (MemPool p, Exp_Dot *a, const Exp_Dot *src)
static ANN void	cpy_exp_lambda (MemPool p, Exp_Lambda *a, const Exp_Lambda *src)
ANN Array_Sub	cpy_array_sub (MemPool p, const Array_Sub src)
ANN Range *	cpy_range (MemPool p, const Range *src)
static ANN void	cpy_exp_array (MemPool p, Exp_Array *a, const Exp_Array *src)
static ANN void	cpy_exp_slice (MemPool p, Exp_Slice *a, const Exp_Slice *src)
ANN Type_Decl *	cpy_type_decl (MemPool p, const Type_Decl *src)
ANN TagList *	cpy_taglist (MemPool p, const TagList *src)
ANN SpecializedList *	cpy_specialized_list (MemPool p, const SpecializedList *src)
ANN void	cpy_tmplarg (MemPool p, const TmplArg *src, TmplArg *tgt)
static ANN void	cpy_variable (MemPool p, Variable *a, const Variable *src)
static ANN void	cpy_exp_decl (MemPool p, Exp_Decl *a, const Exp_Decl *src)
static ANN void	cpy_prim (MemPool p, Exp_Primary *a, const Exp_Primary *src)
ANN Tmpl *	cpy_tmpl (MemPool p, const Tmpl *src)
static ANN void	cpy_exp_call (MemPool p, Exp_Call *a, const Exp_Call *src)
static ANN void	cpy_exp_cast (MemPool p, Exp_Cast *a, const Exp_Cast *src)
static ANN void	cpy_exp_binary (MemPool p, Exp_Binary *a, const Exp_Binary *src)
static ANN void	cpy_exp_postfix (MemPool p, Exp_Postfix *a, const Exp_Postfix *src)
static ANN void	cpy_exp_if (MemPool p, Exp_If *a, const Exp_If *src)
static ANN CaptureList *	cpy_captures (MemPool p, const CaptureList *src)
static ANN void	cpy_exp_unary (MemPool p, Exp_Unary *a, const Exp_Unary *src)
static ANN void	cpy_stmt_exp (MemPool p, const Stmt_Exp a, const struct Stmt_Exp_ *src)
static ANN void	cpy_stmt_flow (MemPool p, Stmt_Flow a, const struct Stmt_Flow_ *src)
static ANN void	cpy_stmt_defer (MemPool p, Stmt_Defer a, const struct Stmt_Defer_ *src)
static ANN void	cpy_stmt_code (MemPool p, Stmt_Code a, const struct Stmt_Code_ *src)
static ANN void	cpy_stmt_for (MemPool p, Stmt_For a, const struct Stmt_For_ *src)
static ANN void	cpy_stmt_each (MemPool p, Stmt_Each a, const struct Stmt_Each_ *src)
static ANN void	cpy_stmt_loop (MemPool p, Stmt_Loop a, const struct Stmt_Loop_ *src)
static ANN void	cpy_stmt_if (MemPool p, Stmt_If a, const struct Stmt_If_ *src)
static ANN void	cpy_stmt_case (MemPool p, const Stmt_Match a, const struct Match *src)
static ANN void	cpy_stmt_pp (MemPool p NUSED, Stmt_PP a, const struct Stmt_PP_ *src)
static ANN StmtList *	cpy_stmt_cases (MemPool p, const StmtList *src)
static ANN HandlerList *	cpy_handler_list (MemPool p, const HandlerList *src)
static ANN void	cpy_stmt_try (MemPool p, Stmt_Try a, const struct Stmt_Try_ *src)
static ANN void	cpy_stmt_match (MemPool p, Stmt_Match a, const struct Match *src)
static ANN EnumValueList *	cpy_enum_list (MemPool p, const EnumValueList *src)
static ANN Enum_Def	cpy_enum_def (MemPool p, const Enum_Def src)
ANN Func_Base *	cpy_func_base (MemPool p, const Func_Base *src)
ANN Fptr_Def	cpy_fptr_def (MemPool p, const Fptr_Def src)
static ANN void	cpy_type_def2 (MemPool p, Type_Def a, const Type_Def src)
static ANN Type_Def	cpy_type_def (MemPool p, const Type_Def src)
ANN VariableList *	cpy_variable_list (MemPool p, const VariableList *src)
ANN Union_Def	cpy_union_def (MemPool p, const Union_Def src)
ANN Stmt *	cpy_stmt3 (MemPool p, const Stmt *src)
static ANN void	cpy_stmt_spread (MemPool p, Spread_Def a, const struct Spread_Def_ *src)
static ANN void	cpy_stmt_using (MemPool p, Stmt_Using a, const struct Stmt_Using_ *src)
static ANN UsingStmtList *	cpy_import_list (MemPool p, const UsingStmtList *src)
static ANN void	cpy_stmt_import (MemPool p, Stmt_Import a, const struct Stmt_Import_ *src)
ANN Func_Def	cpy_func_def (MemPool p, const Func_Def src)
static ANN Trait_Def	cpy_trait_def (MemPool p, const Trait_Def src)
static ANN Prim_Def	cpy_prim_def (MemPool p, const Prim_Def src)
static ANN void	cpy_section (MemPool p, Section *const a, const Section *src)
ANN Extend_Def	cpy_extend_def (MemPool p, const Extend_Def src)
ANN Ast	cpy_ast (MemPool p, Ast src)

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,
		Ast	src )

Definition at line 631 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_captures()

static ANN CaptureList * cpy_captures ( MemPool p, const CaptureList * src )

static

Definition at line 196 of file ast_cpy.c.

                                                                        {
  CaptureList *a = new_capturelist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    // NOTE: use list copy?
    const Capture capture = capturelist_at(src, i);
    capturelist_set(a, i, capture);
  }
  return a;
}

cpy_class_def()

ANN Class_Def cpy_class_def	(	MemPool	p,
		const Class_Def	src )

Definition at line 621 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_enum_def()

static ANN Enum_Def cpy_enum_def ( MemPool p, const Enum_Def src )

static

Definition at line 375 of file ast_cpy.c.

                                                                {
  Enum_Def a = mp_calloc(p, Enum_Def);
  a->list    = cpy_enum_list(p, src->list);
  a->tag     = src->tag;
  a->flag    = src->flag;
  return a;
}

cpy_enum_list()

static ANN EnumValueList * cpy_enum_list ( MemPool p, const EnumValueList * src )

static

Definition at line 369 of file ast_cpy.c.

                                                                             {
  EnumValueList *tgt = new_enumvaluelist(p, src->len);
  memcpy(tgt->ptr, src->ptr, src->len * sizeof(EnumValue)); // TODO: xxxlist copy functions
  return tgt;
}

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_exp_array()

static ANN void cpy_exp_array ( MemPool p, Exp_Array * a, const Exp_Array * src )

static

Definition at line 40 of file ast_cpy.c.

                                                                             {
  a->base  = cpy_exp(p, src->base);
  a->array = cpy_array_sub(p, src->array);
}

cpy_exp_binary()

static ANN void cpy_exp_binary ( MemPool p, Exp_Binary * a, const Exp_Binary * src )

static

Definition at line 177 of file ast_cpy.c.

                                                      {
  a->lhs = cpy_exp(p, src->lhs);
  a->rhs = cpy_exp(p, src->rhs);
  a->op  = src->op;
}

cpy_exp_call()

static ANN void cpy_exp_call ( MemPool p, Exp_Call * a, const Exp_Call * src )

static

Definition at line 166 of file ast_cpy.c.

                                                                          {
  a->func = cpy_exp(p, src->func);
  if (src->args) a->args = cpy_exp(p, src->args);
  if (src->tmpl) a->tmpl = cpy_tmpl(p, src->tmpl);
}

cpy_exp_cast()

static ANN void cpy_exp_cast ( MemPool p, Exp_Cast * a, const Exp_Cast * src )

static

Definition at line 172 of file ast_cpy.c.

                                                                          {
  a->td  = cpy_type_decl(p, src->td);
  a->exp = cpy_exp(p, src->exp);
}

cpy_exp_decl()

static ANN void cpy_exp_decl ( MemPool p, Exp_Decl * a, const Exp_Decl * src )

static

Definition at line 117 of file ast_cpy.c.

                                                                          {
  cpy_variable(p, &a->var, &src->var);
  if(src->args) a->args = cpy_exp(p, src->args);
}

cpy_exp_dot()

static ANN void cpy_exp_dot ( MemPool p, Exp_Dot * a, const Exp_Dot * src )

static

Definition at line 16 of file ast_cpy.c.

                                                                       {
  a->base = cpy_exp(p, src->base);
  cpy_var_decl(p, &a->var, &src->var);
}

cpy_exp_if()

static ANN void cpy_exp_if ( MemPool p, Exp_If * a, const Exp_If * src )

static

Definition at line 190 of file ast_cpy.c.

                                                                    {
  a->cond = cpy_exp(p, src->cond);
  if (src->if_exp) a->if_exp = cpy_exp(p, src->if_exp);
  if (src->else_exp) a->else_exp = cpy_exp(p, src->else_exp);
}

cpy_exp_lambda()

static ANN void cpy_exp_lambda ( MemPool p, Exp_Lambda * a, const Exp_Lambda * src )

static

Definition at line 21 of file ast_cpy.c.

                                                      {
  a->def = cpy_func_def(p, src->def);
}

cpy_exp_postfix()

static ANN void cpy_exp_postfix ( MemPool p, Exp_Postfix * a, const Exp_Postfix * src )

static

Definition at line 184 of file ast_cpy.c.

                                                        {
  a->op  = src->op;
  a->exp = cpy_exp(p, src->exp);
}

cpy_exp_slice()

static ANN void cpy_exp_slice ( MemPool p, Exp_Slice * a, const Exp_Slice * src )

static

Definition at line 45 of file ast_cpy.c.

                                                                             {
  a->base  = cpy_exp(p, src->base);
  a->range = cpy_range(p, src->range);
}

cpy_exp_unary()

static ANN void cpy_exp_unary ( MemPool p, Exp_Unary * a, const Exp_Unary * src )

static

Definition at line 206 of file ast_cpy.c.

                                                                             {
  a->op = src->op;
  switch ((a->unary_type = src->unary_type)) {
  case unary_exp:
    a->exp = cpy_exp(p, src->exp);
    break;
  case unary_td:
    a->ctor.td = cpy_type_decl(p, src->ctor.td);
    if(src->ctor.exp)
      a->ctor.exp = cpy_exp(p, src->ctor.exp);
    break;
  case unary_code:
    a->code = cpy_stmt_list(p, src->code);
    break;
  }
  if(src->captures)
    a->captures = cpy_captures(p, src->captures);
}

cpy_extend_def()

ANN Extend_Def cpy_extend_def	(	MemPool	p,
		const Extend_Def	src )

Definition at line 614 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 Func_Base * cpy_func_base	(	MemPool	p,
		const Func_Base *	src )

Definition at line 383 of file ast_cpy.c.

                                                              {
 Func_Base *a = mp_calloc(p, Func_Base);
  if (src->td) a->td = cpy_type_decl(p, src->td);      // 1
  a->tag = src->tag;                     // 1
  if (src->args) a->args = cpy_arg_list(p, src->args); // 1
  if (src->tmpl) a->tmpl = cpy_tmpl(p, src->tmpl); // 1
  //  if(src->effects.ptr)
  //    vector_copy2((Vector)&src->effects, &a->effects);
  a->flag   = src->flag;
  a->fbflag = src->fbflag;
  return a;
}

cpy_func_def()

ANN Func_Def cpy_func_def	(	MemPool	p,
		const Func_Def	src )

Definition at line 534 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_handler_list()

static ANN HandlerList * cpy_handler_list ( MemPool p, const HandlerList * src )

static

Definition at line 346 of file ast_cpy.c.

                                                                            {
  HandlerList *tgt = new_handlerlist(p, src->len);
  for(m_uint i = 0; i < src->len; i++) {
    const Handler src_handler = handlerlist_at(src, i);
    Handler *tgt_handler = handlerlist_ptr_at(tgt, i);
    tgt_handler->stmt        = cpy_stmt(p, src_handler.stmt);
    tgt_handler->tag         = src_handler.tag;
  }
  return tgt;
}

cpy_import_list()

static ANN UsingStmtList * cpy_import_list ( MemPool p, const UsingStmtList * src )

static

Definition at line 460 of file ast_cpy.c.

                                                                               {
  UsingStmtList *tgt = new_usingstmtlist(p, src->len);
  for(uint32_t i = 0; i < src->len; i++) {
    const UsingStmt  src_item = usingstmtlist_at(src, i);
    Stmt_Using  tgt_item = usingstmtlist_ptr_at(tgt, i);
    tgt_item->tag = src_item.tag;
    if(src_item.d.exp)
      tgt_item->d.exp = cpy_exp(p, src_item.d.exp);
  }
  return tgt;
}

cpy_prim()

static ANN void cpy_prim ( MemPool p, Exp_Primary * a, const Exp_Primary * src )

static

Definition at line 122 of file ast_cpy.c.

                                                                            {
  switch (src->prim_type) {
  case ae_prim_id:
  case ae_prim_locale:
  case ae_prim_perform:
    a->d.var = src->d.var;
    break;
  case ae_prim_num:
    a->d.gwint.num = src->d.gwint.num;
    break;
  case ae_prim_float:
    a->d.fnum = src->d.fnum;
    break;
  case ae_prim_char:
    a->d.chr = src->d.chr;
    break;
  case ae_prim_str:
    a->d.string.data  = src->d.string.data;
    a->d.string.delim = src->d.string.delim;
    break;
  case ae_prim_array:
    a->d.array = cpy_array_sub(p, src->d.array);
    break;
  case ae_prim_range:
    a->d.range = cpy_range(p, src->d.range);
    break;
  default:
    if (src->d.exp) a->d.exp = cpy_exp(p, src->d.exp);
    break;
  }
  a->prim_type = src->prim_type;
}

cpy_prim_def()

static ANN Prim_Def cpy_prim_def ( MemPool p, const Prim_Def src )

static

Definition at line 567 of file ast_cpy.c.

                                                                {
  Prim_Def a = mp_calloc(p, Prim_Def);
  a->tag = src->tag;
  a->size = src->size;
  a->flag = src->flag;
  return a;
}

cpy_range()

ANN Range * cpy_range	(	MemPool	p,
		const Range *	src )

Definition at line 33 of file ast_cpy.c.

                                                  {
  Range *a = mp_calloc(p, Array_Sub);
  if (src->start) a->start = cpy_exp(p, src->start);
  if (src->end) a->end = cpy_exp(p, src->end);
  return a;
}

cpy_section()

static ANN void cpy_section ( MemPool p, Section *const a, const Section * src )

static

Definition at line 575 of file ast_cpy.c.

                                                                             {
//  Section *a = mp_calloc(p, Section);
  switch (src->section_type) {
  case ae_section_stmt:
    //if(src->d.stmt_list)
      a->d.stmt_list = cpy_stmt_list(p, src->d.stmt_list);
    break;
  case ae_section_class:
    a->d.class_def = cpy_class_def(p, src->d.class_def);
    break;
  case ae_section_trait:
    a->d.trait_def = cpy_trait_def(p, src->d.trait_def);
    break;
  case ae_section_extend:
    a->d.extend_def = cpy_extend_def(p, src->d.extend_def);
    break;
  case ae_section_func:
    a->d.func_def = cpy_func_def(p, src->d.func_def);
    break;
  case ae_section_enum:
    a->d.enum_def = cpy_enum_def(p, src->d.enum_def);
    break;
  case ae_section_union:
    a->d.union_def = cpy_union_def(p, src->d.union_def);
    break;
  case ae_section_fptr:
    a->d.fptr_def = cpy_fptr_def(p, src->d.fptr_def);
    break;
  case ae_section_type:
    a->d.type_def = cpy_type_def(p, src->d.type_def);
    break;
    case ae_section_primitive:
    a->d.prim_def = cpy_prim_def(p, src->d.prim_def);
    break;
  }
  a->section_type = src->section_type;
//  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_stmt()

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

Definition at line 434 of file ast_cpy.c.

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

cpy_stmt2()

static ANN void cpy_stmt2 ( MemPool p, Stmt * a, const Stmt * src )

static

Definition at line 479 of file ast_cpy.c.

                                                               {
  switch (src->stmt_type) {
  case ae_stmt_exp:
  case ae_stmt_return:
    cpy_stmt_exp(p, &a->d.stmt_exp, &src->d.stmt_exp);
    break;
  case ae_stmt_code:
    cpy_stmt_code(p, &a->d.stmt_code, &src->d.stmt_code);
    break;
  case ae_stmt_while:
  case ae_stmt_until:
    cpy_stmt_flow(p, &a->d.stmt_flow, &src->d.stmt_flow);
    break;
  case ae_stmt_loop:
    cpy_stmt_loop(p, &a->d.stmt_loop, &src->d.stmt_loop);
    break;
  case ae_stmt_for:
    cpy_stmt_for(p, &a->d.stmt_for, &src->d.stmt_for);
    break;
  case ae_stmt_each:
    cpy_stmt_each(p, &a->d.stmt_each, &src->d.stmt_each);
    break;
  case ae_stmt_if:
    cpy_stmt_if(p, &a->d.stmt_if, &src->d.stmt_if);
    break;
  case ae_stmt_try:
    cpy_stmt_try(p, &a->d.stmt_try, &src->d.stmt_try);
    break;
  case ae_stmt_match:
    cpy_stmt_match(p, &a->d.stmt_match, &src->d.stmt_match);
    break;
  case ae_stmt_pp:
    cpy_stmt_pp(p, &a->d.stmt_pp, &src->d.stmt_pp);
    break;
  case ae_stmt_defer:
    cpy_stmt_defer(p, &a->d.stmt_defer, &src->d.stmt_defer);
    break;
  case ae_stmt_spread:
    cpy_stmt_spread(p, &a->d.stmt_spread, &src->d.stmt_spread);
    break;
  case ae_stmt_using:
    cpy_stmt_using(p, &a->d.stmt_using, &src->d.stmt_using);
    break;
  case ae_stmt_import:
    cpy_stmt_import(p, &a->d.stmt_import, &src->d.stmt_import);
    break;
  case ae_stmt_break:
  case ae_stmt_continue:
  case ae_stmt_retry:
    break;
  }
  a->stmt_type = src->stmt_type;
  a->loc       = src->loc;
}

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_stmt_case()

static ANN void cpy_stmt_case ( MemPool p, const Stmt_Match a, const struct Match * src )

static

Definition at line 323 of file ast_cpy.c.

                                                                                      {
  a->cond = cpy_exp(p, src->cond);
  a->list = cpy_stmt_list(p, src->list);
  if (src->when) a->when = cpy_exp(p, src->when);
}

cpy_stmt_cases()

static ANN StmtList * cpy_stmt_cases ( MemPool p, const StmtList * src )

static

Definition at line 335 of file ast_cpy.c.

                                                                    {
  const m_uint sz = src->len;
  StmtList *a = new_stmtlist(p, sz);
  for(m_uint i = 0; i < sz; i++) {
    Stmt* a_stmt   = stmtlist_ptr_at(a, i);
    Stmt src_stmt = stmtlist_at(src, i);
    cpy_stmt_case(p, &a_stmt->d.stmt_match, &src_stmt.d.stmt_match);
  }
  return a;
}

cpy_stmt_code()

static ANN void cpy_stmt_code ( MemPool p, Stmt_Code a, const struct Stmt_Code_ * src )

static

Definition at line 292 of file ast_cpy.c.

                                                                                    {
  if (src->stmt_list) a->stmt_list = cpy_stmt_list(p, src->stmt_list);
}

cpy_stmt_defer()

static ANN void cpy_stmt_defer ( MemPool p, Stmt_Defer a, const struct Stmt_Defer_ * src )

static

Definition at line 288 of file ast_cpy.c.

                                                                                       {
  a->stmt = cpy_stmt(p, src->stmt);
}

cpy_stmt_each()

static ANN void cpy_stmt_each ( MemPool p, Stmt_Each a, const struct Stmt_Each_ * src )

static

Definition at line 303 of file ast_cpy.c.

                                                                                    {
  a->var  = src->var;
  a->exp  = cpy_exp(p, src->exp);
  a->body = cpy_stmt(p, src->body);
  a->is_ref = src->is_ref;
  if (src->idx.tag.sym) a->idx = src->idx;
}

cpy_stmt_exp()

static ANN void cpy_stmt_exp ( MemPool p, const Stmt_Exp a, const struct Stmt_Exp_ * src )

static

Definition at line 278 of file ast_cpy.c.

                                                                                       {
  if (src->val) a->val = cpy_exp(p, src->val);
}

cpy_stmt_flow()

static ANN void cpy_stmt_flow ( MemPool p, Stmt_Flow a, const struct Stmt_Flow_ * src )

static

Definition at line 282 of file ast_cpy.c.

                                                                                    {
  if (src->cond) a->cond = cpy_exp(p, src->cond);
  if (src->body) a->body = cpy_stmt(p, src->body);
  a->is_do = src->is_do;
}

cpy_stmt_for()

static ANN void cpy_stmt_for ( MemPool p, Stmt_For a, const struct Stmt_For_ * src )

static

Definition at line 296 of file ast_cpy.c.

                                                                                 {
  if (src->c1) a->c1 = cpy_stmt(p, src->c1);
  if (src->c2) a->c2 = cpy_stmt(p, src->c2);
  if (src->c3) a->c3 = cpy_exp(p, src->c3);
  if (src->body) a->body = cpy_stmt(p, src->body);
}

cpy_stmt_if()

static ANN void cpy_stmt_if ( MemPool p, Stmt_If a, const struct Stmt_If_ * src )

static

Definition at line 317 of file ast_cpy.c.

                                                                              {
  if (src->cond) a->cond = cpy_exp(p, src->cond);
  if (src->if_body) a->if_body = cpy_stmt(p, src->if_body);
  if (src->else_body) a->else_body = cpy_stmt(p, src->else_body);
}

cpy_stmt_import()

static ANN void cpy_stmt_import ( MemPool p, Stmt_Import a, const struct Stmt_Import_ * src )

static

Definition at line 472 of file ast_cpy.c.

                                                                                          {
  a->tag = src->tag;
  if(src->selection)
    a->selection = cpy_import_list(p, src->selection);
}

cpy_stmt_list()

ANN StmtList * cpy_stmt_list ( MemPool p, const StmtList * src )

static

Definition at line 547 of file ast_cpy.c.

                                                            {
  const m_uint sz = src->len;
  StmtList *a = new_stmtlist(p, sz);
  for(m_uint i = 0; i < sz; i++) {
    Stmt* astmt = stmtlist_ptr_at(a, i);
    const Stmt sstmt = stmtlist_at(src, i);
    cpy_stmt2(p, astmt, &sstmt);
  }
  return a;
}

cpy_stmt_loop()

static ANN void cpy_stmt_loop ( MemPool p, Stmt_Loop a, const struct Stmt_Loop_ * src )

static

Definition at line 311 of file ast_cpy.c.

                                                                                    {
  a->cond = cpy_exp(p, src->cond);
  a->body = cpy_stmt(p, src->body);
  if (src->idx.tag.sym) a->idx = src->idx;
}

cpy_stmt_match()

static ANN void cpy_stmt_match ( MemPool p, Stmt_Match a, const struct Match * src )

static

Definition at line 362 of file ast_cpy.c.

                                                                                 {
  a->cond = cpy_exp(p, src->cond);
  a->list = cpy_stmt_cases(p, src->list);
  if (src->where) a->where = cpy_stmt(p, src->where);
}

cpy_stmt_pp()

static ANN void cpy_stmt_pp ( MemPool p NUSED, Stmt_PP a, const struct Stmt_PP_ * src )

static

Definition at line 329 of file ast_cpy.c.

                                                                                    {
  if (src->data) a->data = strdup(src->data);
  if (src->exp) a->exp = cpy_exp(p, src->exp);
  a->xid = src->xid;
}

cpy_stmt_spread()

static ANN void cpy_stmt_spread ( MemPool p, Spread_Def a, const struct Spread_Def_ * src )

static

Definition at line 446 of file ast_cpy.c.

                                                                                        {
  a->tag = src->tag;
  a->list = cpy_taglist(p, src->list);
  a->data = mstrdup(p, src->data);
}

cpy_stmt_try()

static ANN void cpy_stmt_try ( MemPool p, Stmt_Try a, const struct Stmt_Try_ * src )

static

Definition at line 357 of file ast_cpy.c.

                                                                                 {
  a->stmt    = cpy_stmt(p, src->stmt);
  a->handler = cpy_handler_list(p, src->handler);
}

cpy_stmt_using()

static ANN void cpy_stmt_using ( MemPool p, Stmt_Using a, const struct Stmt_Using_ * src )

static

Definition at line 452 of file ast_cpy.c.

                                                                                       {
  if(src->tag.sym) {
    a->d.exp = cpy_exp(p, src->d.exp);
    a->tag = src->tag;
  } else
    a->d.td = cpy_type_decl(p, src->d.td);
}

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()

ANN void cpy_tmplarg	(	MemPool	p,
		const TmplArg *	src,
		TmplArg *	tgt )

Definition at line 84 of file ast_cpy.c.

                                                                  {
  tgt->type = src->type;
  if(src->type == tmplarg_td)
    tgt->d.td = cpy_type_decl(p, src->d.td);
  else tgt->d.exp = cpy_exp(p, src->d.exp);
}

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_trait_def()

static ANN Trait_Def cpy_trait_def ( MemPool p, const Trait_Def src )

static

Definition at line 558 of file ast_cpy.c.

                                                                   {
  Trait_Def a = mp_calloc(p, Trait_Def);
  a->tag = src->tag;
  if (src->body) a->body = cpy_ast(p, src->body);
  if (src->traits) a->traits = cpy_taglist(p, src->traits);
  a->flag = src->flag;
  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_type_def()

static ANN Type_Def cpy_type_def ( MemPool p, const Type_Def src )

static

Definition at line 409 of file ast_cpy.c.

                                                                {
  Type_Def a = mp_calloc(p, Type_Def);
  cpy_type_def2(p, a, src);
  return a;
}

cpy_type_def2()

static ANN void cpy_type_def2 ( MemPool p, Type_Def a, const Type_Def src )

static

Definition at line 402 of file ast_cpy.c.

                                                                         {
  a->tag = src->tag;
  if (src->ext) a->ext = cpy_type_decl(p, src->ext);
  if (src->when) a->when = cpy_exp(p, src->when);
  if (src->tmpl) a->tmpl = cpy_tmpl(p, src->tmpl);
}

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_var_decl()

static ANN void cpy_var_decl ( MemPool p NUSED, Var_Decl * a, const Var_Decl * src )

static

Definition at line 12 of file ast_cpy.c.

                                                                                {
  a->tag = src->tag;
}

cpy_variable()

static ANN void cpy_variable ( MemPool p, Variable * a, const Variable * src )

static

Definition at line 101 of file ast_cpy.c.

                                                                          {
  if (src->td) a->td = cpy_type_decl(p, src->td);
  cpy_var_decl(p, &a->vd, &src->vd);
}

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;
}