Patch title: Release 84 bulk changes
Abstract:
File: /pliant/language/compiler/active.c
Key:
    Removed line
    Added line
   
// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it an
// modify it under the terms of the GNU General Public Licen
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be u
// but WITHOUT ANY WARRANTY; without even the implied warran
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// version 2 along with this program; if not, write to the F
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA


static Void active_type_Function(Arrow object,Int access,str
// Copyright  Hubert Tonneau  hubert.tonneau@pliant.cx
//
// This program is free software; you can redistribute it an
// modify it under the terms of the GNU General Public Licen
// as published by the Free Software Foundation.
// 
// This program is distributed in the hope that it will be u
// but WITHOUT ANY WARRANTY; without even the implied warran
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public
// version 2 along with this program; if not, write to the F
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA


static Void active_type_Function(Arrow object,Int access,str
  struct Function *f; Address old;
  struct Function *f; Address old; struct Str temp;
  Int i; struct FunctionPrototype *fi; struct Expression *ei
  struct Instruction *instr; struct Argument *arg; Int a;
  check(entry_type(object)==G.type_Function);
  f=(struct Function *)object;
  if(f->flags&Function_flag_hidden) return;
  // begin of pom patch
  if(f->nb_arg==0 && f->nb_arg!=e->arguments.nb) {
    // try to compile e with no arguments, then the result w
    struct Expression *node, *args;
    node=entry_new(G.type_Expression); entry_lock(node);
    Arrow_copy((Arrow *)&e->module,(Arrow *)&node->module);
    ListingPosition_copy(&e->position,&node->position);
    Arrow_set(&node->value,e->value);
    active_type_Function(object,access,node);
    if(Expression_is_compiled(node) && !error_notified()) {
      args=entry_new(G.type_Expression); entry_lock(args);
      Expression_copy(e,args);
      Expression_compile_step4(args,node->result,node->acces
      if(Expression_is_compiled(args) && !error_notified()) 
        Expression_suckup(e,node);
        Expression_suckup(e,args);
        Expression_set_result(e,args->result,args->access|(D
      entry_unlock(args); }
    entry_unlock(node);
    return; }
  // end of pom patch
  if(f->nb_arg!=e->arguments.nb) return;
  if(f->extra_module!=null)
    old=Relation_define(&e->module->visibles,f->extra_module
  for(i=0; i<f->nb_arg; i++) {
    fi=f->arguments+i,ei=EARG(e,i);
    if(!Expression_cast(ei,fi->type)) goto escape;
    if((fi->access&Access_write) && !(ei->access&Access_writ
    if((fi->access&Access_object) && !(ei->access&Access_obj
  Int i; struct FunctionPrototype *fi; struct Expression *ei
  struct Instruction *instr; struct Argument *arg; Int a;
  check(entry_type(object)==G.type_Function);
  f=(struct Function *)object;
  if(f->flags&Function_flag_hidden) return;
  // begin of pom patch
  if(f->nb_arg==0 && f->nb_arg!=e->arguments.nb) {
    // try to compile e with no arguments, then the result w
    struct Expression *node, *args;
    node=entry_new(G.type_Expression); entry_lock(node);
    Arrow_copy((Arrow *)&e->module,(Arrow *)&node->module);
    ListingPosition_copy(&e->position,&node->position);
    Arrow_set(&node->value,e->value);
    active_type_Function(object,access,node);
    if(Expression_is_compiled(node) && !error_notified()) {
      args=entry_new(G.type_Expression); entry_lock(args);
      Expression_copy(e,args);
      Expression_compile_step4(args,node->result,node->acces
      if(Expression_is_compiled(args) && !error_notified()) 
        Expression_suckup(e,node);
        Expression_suckup(e,args);
        Expression_set_result(e,args->result,args->access|(D
      entry_unlock(args); }
    entry_unlock(node);
    return; }
  // end of pom patch
  if(f->nb_arg!=e->arguments.nb) return;
  if(f->extra_module!=null)
    old=Relation_define(&e->module->visibles,f->extra_module
  for(i=0; i<f->nb_arg; i++) {
    fi=f->arguments+i,ei=EARG(e,i);
    if(!Expression_cast(ei,fi->type)) goto escape;
    if((fi->access&Access_write) && !(ei->access&Access_writ
    if((fi->access&Access_object) && !(ei->access&Access_obj
  Dictionary_insert(&e->properties,Str_map_string(&temp,"active"),true,f);
  instr=(struct Instruction *)entry_new(G.type_Instruction);
  Instruction_set_function(instr,f);
  for(i=0; i<f->nb_arg; i++) {
    fi=f->arguments+i,ei=EARG(e,i);
    Instruction_set_argument(instr,i,ei->result);
    Expression_suckup(e,ei); }
  if(f->nb_arg<f->nb_argres) {
    if(f->arguments[f->nb_arg].access&Access_mapped) {
      arg=argument(f->arguments[f->nb_arg].type,Argument_ind
    other
      arg=argument(f->arguments[f->nb_arg].type,Argument_loc
    Instruction_set_argument(instr,f->nb_arg,arg);
    a=f->arguments[f->nb_arg].access;
    Expression_set_result(e,arg,
      (a&Access_result_read ? Access_read : 0)|
      (a&Access_result_write ? Access_write : 0)|
      (a&Access_object ? Access_object : 0)|
      (a&Access_result_consistent ? EARG(e,0)->access&(Acces
  other
    Expression_set_void_result(e); }
  e->access|=f->definition;
  Expression_add(e,instr);
  escape:
  if(f->extra_module!=null)
    Relation_define(&e->module->visibles,f->extra_module,nul


static Void active_type_Meta(Arrow object,Int access,struct 
  instr=(struct Instruction *)entry_new(G.type_Instruction);
  Instruction_set_function(instr,f);
  for(i=0; i<f->nb_arg; i++) {
    fi=f->arguments+i,ei=EARG(e,i);
    Instruction_set_argument(instr,i,ei->result);
    Expression_suckup(e,ei); }
  if(f->nb_arg<f->nb_argres) {
    if(f->arguments[f->nb_arg].access&Access_mapped) {
      arg=argument(f->arguments[f->nb_arg].type,Argument_ind
    other
      arg=argument(f->arguments[f->nb_arg].type,Argument_loc
    Instruction_set_argument(instr,f->nb_arg,arg);
    a=f->arguments[f->nb_arg].access;
    Expression_set_result(e,arg,
      (a&Access_result_read ? Access_read : 0)|
      (a&Access_result_write ? Access_write : 0)|
      (a&Access_object ? Access_object : 0)|
      (a&Access_result_consistent ? EARG(e,0)->access&(Acces
  other
    Expression_set_void_result(e); }
  e->access|=f->definition;
  Expression_add(e,instr);
  escape:
  if(f->extra_module!=null)
    Relation_define(&e->module->visibles,f->extra_module,nul


static Void active_type_Meta(Arrow object,Int access,struct 
  struct Function *f; Address old;
  struct Function *f; Address old;struct Str temp;
  check(entry_type(object)==G.type_Meta);
  f=(struct Function *)object;
  if(f->extra_module!=null)
    old=Relation_define(&e->module->visibles,f->extra_module
  ((FunctionMacroPrototype)f->exe)(e);
  if(f->extra_module!=null)
    Relation_define(&e->module->visibles,f->extra_module,nul
  if(Expression_is_compiled(e)) {
  check(entry_type(object)==G.type_Meta);
  f=(struct Function *)object;
  if(f->extra_module!=null)
    old=Relation_define(&e->module->visibles,f->extra_module
  ((FunctionMacroPrototype)f->exe)(e);
  if(f->extra_module!=null)
    Relation_define(&e->module->visibles,f->extra_module,nul
  if(Expression_is_compiled(e)) {
    Dictionary_insert(&e->properties,Str_map_string(&temp,"active"),true,f);
    e->access|=f->definition;
  // begin of pom patch
  orif(e->arguments.nb!=0)
    // try to compile e with no arguments, then the result w
    struct Expression *node, *args;
    node=entry_new(G.type_Expression); entry_lock(node);
    Arrow_copy((Arrow *)&e->module,(Arrow *)&node->module);
    ListingPosition_copy(&e->position,&node->position);
    Arrow_set(&node->value,e->value);
    active_type_Meta(object,access,node);
    if(Expression_is_compiled(node) && !error_notified()) {
      args=entry_new(G.type_Expression); entry_lock(args);
      Expression_copy(e,args);
      Expression_compile_step4(args,node->result,node->acces
      if(Expression_is_compiled(args) && !error_notified()) 
        Expression_suckup(e,node);
        Expression_suckup(e,args);
        Expression_set_result(e,args->result,args->access|(D
      entry_unlock(args); }
    entry_unlock(node); } }
  // end of pom patch


static Void active_type_Argument(Arrow object,Int access,str
  struct Argument *arg; struct Expression *e0;
  struct Expression *expr,*sub; Int i; Arrow id;
  struct Type *t;
  struct Argument2 *arg2;
  check(entry_type(object)==G.type_Argument);
  arg=(struct Argument *)object;
  if(e->arguments.nb==0) {
    Expression_set_result(e,arg,access);
  other
    e0=EARG(e,0);
    // try first argument as method argument
    if(e0->arguments.nb==0 && entry_type(e0->value)==G.type_
      expr=entry_new(G.type_Expression); entry_lock(expr);
      Arrow_copy((Arrow *)&e0->module,(Arrow *)&expr->module
      ListingPosition_copy(&e0->position,&expr->position);
      Array_resize(&expr->arguments,e->arguments.nb);
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      ListingPosition_copy(&e->position,&sub->position);
      arg2=(struct Argument2 *)entry_new(G.type_Argument2);
      Arrow_set((Arrow *)&arg2->argument,arg);
      arg2->access=access;
      Arrow_set(&sub->value,arg2);
      Array_set_index(&expr->arguments,0,sub);
      for(i=1; i<e->arguments.nb; i++)
        Array_set_index(&expr->arguments,i,Array_get_index(&
      id=(struct Ident *)entry_new(G.type_Ident); entry_lock
      Str_concat((struct Str *)id,Z,". ",S,e0->value,END);
      Expression_compile_step4(expr,id,Access_constant);
      entry_unlock(id);
      if(!error_notified() && Expression_is_compiled(expr)) 
    e->access|=f->definition;
  // begin of pom patch
  orif(e->arguments.nb!=0)
    // try to compile e with no arguments, then the result w
    struct Expression *node, *args;
    node=entry_new(G.type_Expression); entry_lock(node);
    Arrow_copy((Arrow *)&e->module,(Arrow *)&node->module);
    ListingPosition_copy(&e->position,&node->position);
    Arrow_set(&node->value,e->value);
    active_type_Meta(object,access,node);
    if(Expression_is_compiled(node) && !error_notified()) {
      args=entry_new(G.type_Expression); entry_lock(args);
      Expression_copy(e,args);
      Expression_compile_step4(args,node->result,node->acces
      if(Expression_is_compiled(args) && !error_notified()) 
        Expression_suckup(e,node);
        Expression_suckup(e,args);
        Expression_set_result(e,args->result,args->access|(D
      entry_unlock(args); }
    entry_unlock(node); } }
  // end of pom patch


static Void active_type_Argument(Arrow object,Int access,str
  struct Argument *arg; struct Expression *e0;
  struct Expression *expr,*sub; Int i; Arrow id;
  struct Type *t;
  struct Argument2 *arg2;
  check(entry_type(object)==G.type_Argument);
  arg=(struct Argument *)object;
  if(e->arguments.nb==0) {
    Expression_set_result(e,arg,access);
  other
    e0=EARG(e,0);
    // try first argument as method argument
    if(e0->arguments.nb==0 && entry_type(e0->value)==G.type_
      expr=entry_new(G.type_Expression); entry_lock(expr);
      Arrow_copy((Arrow *)&e0->module,(Arrow *)&expr->module
      ListingPosition_copy(&e0->position,&expr->position);
      Array_resize(&expr->arguments,e->arguments.nb);
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      ListingPosition_copy(&e->position,&sub->position);
      arg2=(struct Argument2 *)entry_new(G.type_Argument2);
      Arrow_set((Arrow *)&arg2->argument,arg);
      arg2->access=access;
      Arrow_set(&sub->value,arg2);
      Array_set_index(&expr->arguments,0,sub);
      for(i=1; i<e->arguments.nb; i++)
        Array_set_index(&expr->arguments,i,Array_get_index(&
      id=(struct Ident *)entry_new(G.type_Ident); entry_lock
      Str_concat((struct Str *)id,Z,". ",S,e0->value,END);
      Expression_compile_step4(expr,id,Access_constant);
      entry_unlock(id);
      if(!error_notified() && Expression_is_compiled(expr)) 
        Dictionary_copy(&expr->properties, &e0->properties);
        Expression_suckup(e,expr);
        Expression_set_result(e,expr->result,expr->access); 
      Expression_suckup_error(e,expr);
      Expression_suckup_error(e,sub);
      entry_unlock(expr); }
    // try no argument as method argument
    if(!Expression_is_compiled(e) && !error_notified()) {
      expr=entry_new(G.type_Expression); entry_lock(expr);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&expr->module)
      ListingPosition_copy(&e->position,&expr->position);
      Array_resize(&expr->arguments,e->arguments.nb+1);
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      ListingPosition_copy(&e->position,&sub->position);
      arg2=(struct Argument2 *)entry_new(G.type_Argument2);
      Arrow_set((Arrow *)&arg2->argument,arg);
      arg2->access=access;
      Arrow_set(&sub->value,arg2);
      Array_set_index(&expr->arguments,0,sub);
      for(i=0; i<e->arguments.nb; i++)
        Array_set_index(&expr->arguments,i+1,Array_get_index
      id=entry(G.type_Ident,"",END); entry_lock(id);
      Expression_compile_step4(expr,id,Access_constant);
      entry_unlock(id);
      if(!error_notified() && Expression_is_compiled(expr)) 
        Expression_suckup(e,expr);
        Expression_set_result(e,expr->result,expr->access); 
      Expression_suckup_error(e,expr);
      Expression_suckup_error(e,sub);
      entry_unlock(expr); }
    /*
    // try to apply on the real data type
    if(!Expression_is_compiled(e) && !error_notified()) {
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      Expression_set_result(sub,arg,access);
      t=Type_real_data_type(arg->type);
      if(t!=arg->type && Expression_cast(sub,t)) {
        expr=(struct Expression *)entry_new(G.type_Expressio
        Expression_copy(e,expr);
        compile_Argument(sub->result,sub->access,expr);
        if(Expression_is_compiled(expr)) {
          Expression_suckup(e,sub);
          Expression_suckup(e,expr);
          Expression_set_result(e,expr->result,expr->access)
        entry_unlock(expr); }
      entry_unlock(sub); } */ } }


static Void active_type_LocalVariable(Arrow object,Int acces
        Expression_suckup(e,expr);
        Expression_set_result(e,expr->result,expr->access); 
      Expression_suckup_error(e,expr);
      Expression_suckup_error(e,sub);
      entry_unlock(expr); }
    // try no argument as method argument
    if(!Expression_is_compiled(e) && !error_notified()) {
      expr=entry_new(G.type_Expression); entry_lock(expr);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&expr->module)
      ListingPosition_copy(&e->position,&expr->position);
      Array_resize(&expr->arguments,e->arguments.nb+1);
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      ListingPosition_copy(&e->position,&sub->position);
      arg2=(struct Argument2 *)entry_new(G.type_Argument2);
      Arrow_set((Arrow *)&arg2->argument,arg);
      arg2->access=access;
      Arrow_set(&sub->value,arg2);
      Array_set_index(&expr->arguments,0,sub);
      for(i=0; i<e->arguments.nb; i++)
        Array_set_index(&expr->arguments,i+1,Array_get_index
      id=entry(G.type_Ident,"",END); entry_lock(id);
      Expression_compile_step4(expr,id,Access_constant);
      entry_unlock(id);
      if(!error_notified() && Expression_is_compiled(expr)) 
        Expression_suckup(e,expr);
        Expression_set_result(e,expr->result,expr->access); 
      Expression_suckup_error(e,expr);
      Expression_suckup_error(e,sub);
      entry_unlock(expr); }
    /*
    // try to apply on the real data type
    if(!Expression_is_compiled(e) && !error_notified()) {
      sub=(struct Expression *)entry_new(G.type_Expression);
      Arrow_copy((Arrow *)&e->module,(Arrow *)&sub->module);
      Expression_set_result(sub,arg,access);
      t=Type_real_data_type(arg->type);
      if(t!=arg->type && Expression_cast(sub,t)) {
        expr=(struct Expression *)entry_new(G.type_Expressio
        Expression_copy(e,expr);
        compile_Argument(sub->result,sub->access,expr);
        if(Expression_is_compiled(expr)) {
          Expression_suckup(e,sub);
          Expression_suckup(e,expr);
          Expression_set_result(e,expr->result,expr->access)
        entry_unlock(expr); }
      entry_unlock(sub); } */ } }


static Void active_type_LocalVariable(Arrow object,Int acces
  struct LocalVariable *l;
  struct LocalVariable *l; struct Str temp;
  check(entry_type(object)==G.type_LocalVariable);
  l=(struct LocalVariable *)object;
  if(l->function!=current_function())
    return;
  if(l->body->type!=null) {
    Expression_compile_step4(e,l->body,l->access);
  check(entry_type(object)==G.type_LocalVariable);
  l=(struct LocalVariable *)object;
  if(l->function!=current_function())
    return;
  if(l->body->type!=null) {
    Expression_compile_step4(e,l->body,l->access);
    if(Expression_is_compiled(e))
    if(Expression_is_compiled(e)) {
      e->access|=Definition_strong;
      e->access|=Definition_strong;
      Dictionary_insert(&e->properties,Str_map_string(&temp,"active"),true,object); }
  other
    error_notifyn(error_id_compile,Z,"Type of argument ",S,&


static Void active_type_GlobalVariable(Arrow object,Int acce
  struct GlobalVariable *gv;
  struct Argument *a,*a2;
  Arrow *c; struct Str temp;
  check(entry_type(object)==G.type_GlobalVariable);
  other
    error_notifyn(error_id_compile,Z,"Type of argument ",S,&


static Void active_type_GlobalVariable(Arrow object,Int acce
  struct GlobalVariable *gv;
  struct Argument *a,*a2;
  Arrow *c; struct Str temp;
  check(entry_type(object)==G.type_GlobalVariable);
  Dictionary_insert(&e->properties,Str_map_string(&temp,"active"),true,object);
  gv=(struct GlobalVariable *)object;
  a=argument(G.type_Address,Argument_constant,entry(G.type_A
  List_append(&a->requires,gv->variable);
  a2=argument(entry_type(gv->variable),Argument_indirect,a,0
  Expression_compile_step4(e,a2,gv->access);
  entry_unlock(a2);
  c=Module_first(e->module,Str_map_string(&temp,"pliant func
  if(c!=G.null_constant) {
    check(entry_type(*c)==G.type_Function || entry_type(*c)=
    ((struct Function *)*c)->flags|=Function_flag_has_side_e








  gv=(struct GlobalVariable *)object;
  a=argument(G.type_Address,Argument_constant,entry(G.type_A
  List_append(&a->requires,gv->variable);
  a2=argument(entry_type(gv->variable),Argument_indirect,a,0
  Expression_compile_step4(e,a2,gv->access);
  entry_unlock(a2);
  c=Module_first(e->module,Str_map_string(&temp,"pliant func
  if(c!=G.null_constant) {
    check(entry_type(*c)==G.type_Function || entry_type(*c)=
    ((struct Function *)*c)->flags|=Function_flag_has_side_e