Changeset 0e767dc in tol

Timestamp:

Jul 3, 2012, 9:33:03 PM (14 years ago)

Author:

Víctor de Buen <vdebuen@…>

Branches:

1941-docker-image-to-test, devel, master

Children:

8e7b274

Parents:

0d63276

Message:

Fixes #1558 in 3.2
Fixes #1559 in 3.2
Fixes #1560 in 3.2

git-svn-id: ​https://www.tol-project.org/svn/tolp/trunk@4914 be4846ae-f051-483a-831f-b64e7d08527f

Location:

tol

Files:

• OIS/oisloader.cpp (modified) (8 diffs)
• btol/bgrammar/class.cpp (modified) (23 diffs)
• btol/bgrammar/oprimp.cpp (modified) (4 diffs)
• btol/bgrammar/spfuninst.cpp (modified) (7 diffs)
• btol/bgrammar/tol_bclass.h (modified) (5 diffs)

tol/OIS/oisloader.cpp

@@ -510 +510 @@
       mbr->isStatic_ = isStatic!=0;
       mbr->isGood_ = true;
-      mbr->BuildMethod();
-      mbr->BuildStatic();
+      mbr->BuildAll();
     }
     else
@@ -842 +841 @@
     else if(mode==BCLASSMODE) 
     { 
-      BClass* cls = BClass::PredeclareClass(name);
+      BClass* cls = BClass::PredeclareClassIfNeeded(name);
       Ensure(cls);
       Ensure(Read(*cls,object_));
@@ -1041 +1040 @@
               ERead(className, set_);
             //Std(BText("\nBOisLoader::ReadNextObject Predeclared Class ")+className);
-              BClass::PredeclareClass(className);
+              BClass::PredeclareClassIfNeeded(className);
             }
           }
@@ -1090 +1089 @@
               ERead(className, set_);
             //Std(BText("\nBOisLoader::ReadNextObject Predeclared Class ")+className);
-              BClass::PredeclareClass(className);
+              BClass::PredeclareClassIfNeeded(className);
             }
           }
@@ -1155 +1154 @@
           ERead(offset, object_);
           set_->SetPos(offset);
+          BGrammar::IncLevel();
           if(control_.oisEngine_.oisVersion_>="02.15")
           {
@@ -1164 +1164 @@
               ERead(className, set_);
             //Std(BText("\nBOisLoader::ReadNextObject Predeclared Class ")+className);
-              BClass::PredeclareClass(className);
+              BClass::PredeclareClassIfNeeded(className);
             }
           }
@@ -1205 +1205 @@
               BText className;
               ERead(className, set_);
-              BClass::PredeclareClass(className);
+              BClass::PredeclareClassIfNeeded(className);
             }
           }
@@ -1224 +1224 @@
           BSyntaxObject* r=NULL;
           x.Set().PrepareStore(s);
-          BGrammar::IncLevel();
           for(n=1; n<=s; n++)
           {

tol/btol/bgrammar/class.cpp

@@ -66 +66 @@
   isStatic_    (false),
   static_      (NULL),
-  description_ ("") 
+  description_ (""),
+  type_        (NULL),
+  class_       (NULL),
+  struct_      (NULL)
 {
 }
@@ -85 +88 @@
   isStatic_    (false),
   static_      (NULL),
-  description_ ("") 
+  description_ (""),
+  type_        (NULL),
+  class_       (NULL),
+  struct_      (NULL) 
 { 
   Copy(mbr); 
 }
+
+
+//--------------------------------------------------------------------
+  void CleanLeftAndRightChar(BText& expression, char begin, char end)
+//--------------------------------------------------------------------
+{
+  int fst = 0;
+  int lst = expression.Length()-1;
+  while(expression[fst]==begin) { fst++; }
+  while(expression[lst]==end  ) { lst--; }
+  expression = expression.SubString(fst,lst);
+}
+
+
 //--------------------------------------------------------------------
 BMember::BMember(BMemberOwner* parent, List* branch)
@@ -104 +124 @@
   isStatic_    (false),
   static_      (NULL),
-  description_ ("") 
+  description_ (""),
+  type_        (NULL),
+  class_       (NULL),
+  struct_      (NULL) 
 {
   List* cdr;
@@ -159 +182 @@
       else if(expression[0]=='{')
       {
-        expression = expression.SubString(1,expression.Length()-2);
+        CleanLeftAndRightChar(expression,'{','}');
       }
       int posEq = expression.Find("=");
@@ -265 +288 @@
         {
           name_ = simpleDec.SubString(p0+1,p1-1);
+          CleanLeftAndRightChar(name_,'{','}');
         }
       }
     } 
     //Cleaning open and close parenthesis
-    if(declaration_[0]=='{')
-    {
-      declaration_=declaration_.SubString(1,declaration_.Length()-2);
-    }
+    CleanLeftAndRightChar(declaration_,'{','}');
   }
   //Checking mandatory information: name and declaration. 
@@ -293 +314 @@
             I2(" of Class ", " de Class ")+parent->getFullName());
   }
-  if(parent->OwnerType()==BMemberOwner::BCLASS)
-  {
-    BuildMethod();
-    BuildStatic();
-  }
+  BuildAll();
 }
 
@@ -360 +377 @@
   isStatic_     = mbr.isStatic_; 
   static_       = mbr.static_; 
+  type_         = mbr.type_; 
+  class_        = mbr.class_; 
+  struct_       = mbr.struct_; 
   if(method_) { method_->IncNRefs(); }
   if(static_) { static_->IncNRefs(); }
@@ -483 +503 @@
   }
 }
+
+//--------------------------------------------------------------------
+  int BMember::BuildType()
+//! Builds type information
+//--------------------------------------------------------------------
+{
+  if(isMethod_) { type_ = GraCode(); }
+  else
+  {
+    BText typeDec = declaration_+" ";
+    typeDec.Replace(BText(" ")+name_+" ","");
+    typeDec.Compact();
+    class_ = FindClass(typeDec,-1);
+    if(class_) { type_ = GraNameBlock(); }
+    else
+    {
+      struct_ = FindStruct(typeDec);
+      if(struct_) { type_ = GraSet(); }
+      else
+      {
+        type_ = BGrammar::FindByName(typeDec,false);
+        if(!type_)
+        {
+          isGood_ = false;
+          Error(I2("Unknown type declaration of member ",
+                   "Tipo descponocido en declaración de miembro ")+
+          BParser::Unparse(branch_,"","\n")+
+          I2(" of Class ", " de Class ")+parent_->getFullName() );
+          return(-1);
+        }
+      }
+    }
+  }
+  return(0);
+}
+
+//--------------------------------------------------------------------
+  int BMember::BuildAll()
+//--------------------------------------------------------------------
+{
+  if(parent_->OwnerType()==BMemberOwner::BCLASS)
+  {
+    BuildMethod();
+    BuildStatic();
+  }
+  BuildType();
+  return(0);
+}
+
 //--------------------------------------------------------------------
   bool BMember::HasDefVal() const 
@@ -747 +816 @@
   if(!parent) { return(false); }
   if(this==parent) { return(true); }
-  return(InheritesFrom(parent->getFullNameRef()));
+  BClassByNameHash::const_iterator iterA;
+  BClassByNameHash& ah = *ascentHash_;
+  for(iterA=ah.begin(); iterA!=ah.end(); iterA++)
+  {
+    if(iterA->second==parent) { return(true); }
+  }
+  return(false); 
+//return(InheritesFrom(parent->getFullNameRef()));
 //return(InheritesFrom(parent->Name()));
 }
@@ -819 +895 @@
 {
   if(!isGood_) { return(false); }
-  const BText& dec  = newMember->declaration_;
+  const BText* dec  = &(newMember->declaration_);
   const BText& name = newMember->name_;
-  assert(name.HasName()&& dec.HasName());
+  assert(name.HasName()&& dec->HasName());
 
   if(OwnerType()==BCLASS)
@@ -847 +923 @@
   BMbrNum* mbrNum = FindMbrNum(name);
   BMember* member = (mbrNum)?mbrNum->member_:NULL;
+  if(member)
+  {
+    if(member->type_ == newMember->type_)
+    {
+      if( ((member->type_==GraSet())&&member->struct_&&(member->struct_==newMember->struct_))
+          ||
+          ((member->type_==GraNameBlock())&&member->class_&&(member->class_==newMember->class_)) )
+      {
+        dec = &(member->declaration_);
+      }
+    } 
+  }
   //Searches for existant member with same declaration but no default value
-  BMember* mbrDec = FindDecMember(dec);
+  BMember* mbrDec = FindDecMember(*dec);
   //Searches for existant member with same declaration and with default value
-  BMember* mbrDef = FindDefMember(dec);
+  BMember* mbrDef = FindDefMember(*dec);
+
   bool isMethod = newMember->isMethod_;
   if(!member)
@@ -858 +947 @@
     (*memberHash_)[name] = newMbrNum;
     //It's also added to correspondent map hashed by declaration
-    if(hasDefVal) { (*mbrDefHash_)[dec] = newMember; }
-    else          { (*mbrDecHash_)[dec] = newMember; }
+    if(hasDefVal) { (*mbrDefHash_)[*dec] = newMember; }
+    else          { (*mbrDecHash_)[*dec] = newMember; }
     if(isMethod && !hasDefVal) { notImplementedMethods_++; }
   }
@@ -895 +984 @@
       memberHash_->erase(name);
       assert(!FindMember(name));
-      mbrDefHash_->erase(dec);
-      assert(!FindDefMember(dec));
+      mbrDefHash_->erase(*dec);
+      assert(!FindDefMember(*dec));
       (*memberHash_)[name] = newMbrNum;
-      (*mbrDefHash_)[dec ] = newMember;
+      (*mbrDefHash_)[*dec] = newMember;
       newMember->firstParent_ = mbrDef->firstParent_;
     }
@@ -907 +996 @@
       memberHash_->erase(name);
       assert(!FindMember(name));
-      mbrDecHash_->erase(dec);
-      assert(!FindDecMember(dec));
-      (*memberHash_)[name]= newMbrNum;
-      (*mbrDefHash_)[dec] = newMember;
+      mbrDecHash_->erase(*dec);
+      assert(!FindDecMember(*dec));
+      (*memberHash_)[name] = newMbrNum;
+      (*mbrDefHash_)[*dec] = newMember;
       if(isMethod) 
       { 
@@ -953 +1042 @@
   " \n  class:"+Name()+
   " \n  member name:"+name+
-  " \n  member declaration:"+dec+"\n");
+  " \n  member declaration:"+*dec+"\n");
 */
   return(ok);
@@ -1193 +1282 @@
   __destroy(NULL)
 {
+  if(name=="@BsrMaster")
+    printf(""); 
   CreateMemberHashes();
   CreateParentHashes();
@@ -1665 +1756 @@
 
 //--------------------------------------------------------------------
-  BClass* BClass::PredeclareClass(
+static BClass* FindClassInNameBlock(
+  const BText& name,
+  BUserNameBlock*& unb )
+//--------------------------------------------------------------------
+{
+  BClass* cls = NULL;
+  BSyntaxObject* obj;
+  int pos = name.Find("::",0);
+  if(pos>=0)
+  {
+    BText prefix;
+    BText suffix;
+    prefix = name.SubString(0,pos-1);
+    suffix  = name.SubString(pos+2,name.Length());
+    if(!unb)
+    {
+      obj = GraNameBlock()->FindOperand(prefix,false);
+      if(obj && obj->Grammar()==GraNameBlock())
+      {
+        unb = (BUserNameBlock*)obj;
+      }
+    }
+    else
+    {
+      BNameBlock& nb = unb->Contens();
+      obj = nb.Member(prefix);
+      if(obj && obj->Grammar()==GraNameBlock())
+      {
+        unb = (BUserNameBlock*)obj;
+      }
+      else
+      {
+        unb = NULL;
+      }
+    }
+    if(unb) 
+    {
+      cls = FindClassInNameBlock(suffix, unb);         
+    }
+  }
+  else if(unb)
+  {
+    BNameBlock& nb = unb->Contens();
+    obj = nb.Member(name);
+    if(obj && obj->Mode()==BCLASSMODE)
+    {
+      cls = (BClass*)obj;
+    }
+  }
+  return(cls); 
+}
+
+
+//--------------------------------------------------------------------
+static BClass* FindNonMemberClass(const BText& name, int defined)
+
+/*! Searches a user class wich name is name and returns it.
+ *  If itsn't exists returns NIL.
+ */
+//--------------------------------------------------------------------
+{
+  BClass* cls = BStackManager::FindClass(name);
+  if(!cls)
+  {
+    BObjClassify oc(GraAnything(),BCLASSMODE);
+    cls= (BClass*)BGrammar::SymbolTable().Search(oc, name);
+  }
+  return(cls);
+}
+
+//--------------------------------------------------------------------
+BClass* FindClass(const BText& name, int defined)
+
+/*! Searches a user class wich name is name and returns it.
+ *  If itsn't exists returns NIL.
+ */
+//--------------------------------------------------------------------
+{
+  BSyntaxObject* result = NULL;
+  BUserNameBlock* unb = NULL;
+  BClass* cls = FindClassInNameBlock(name, unb);
+  if(!cls && BNameBlock::Current())
+  {
+    result = BNameBlock::Current()->Member(name);
+    if(result && (result->Mode()==BCLASSMODE))
+    {
+      cls = (BClass*)result;
+    }
+  }
+  if(!cls)
+  {
+    cls = BStackManager::FindClass(name);
+  }
+  if(!cls)
+  {
+    result = BNameBlock::LocalMember(name);
+    if(result && (result->Mode()==BCLASSMODE))
+    {
+      cls = (BClass*)result;
+    }
+  }
+  if(!cls) 
+  {
+    BObjClassify oc(GraAnything(),BCLASSMODE);
+    cls= (BClass*)BGrammar::SymbolTable().Search(oc, name);
+  }
+  if(!cls) 
+  {
+    result = BNameBlock::UsingMember(name);
+    if(result && (result->Mode()==BCLASSMODE))
+    {
+      cls = (BClass*)result;
+    }
+  }
+  if(cls && (defined>=0) && (cls->isDefined_!=(defined!=0)))
+  {
+    cls = NULL;
+  }
+  return(cls);
+}
+
+//--------------------------------------------------------------------
+  BClass* BClass::GetClassIfExist(const BText& name)
+//--------------------------------------------------------------------
+{
+  if(name=="@BsrMaster")
+    printf(""); 
+  BClass* old = NULL;
+  if(name.HasName())
+  {
+    BUserNameBlock* bnbP = BNameBlock::Building();
+    if(bnbP)
+    {
+      old = BStackManager::FindClass(name);
+      if(old && (old->Level()!=BGrammar::Level()))
+      {
+        old = NULL;
+      }
+    }
+    else
+    {
+      old = FindClass(name,-1);
+    }  
+  }
+  return(old); 
+}
+
+//--------------------------------------------------------------------
+  BClass* BClass::PredeclareClassIfNeeded(const BText& name)
+//--------------------------------------------------------------------
+{
+  BClass* class_ = BClass::GetClassIfExist(name);
+  if(!class_) 
+  {
+    class_ = new BClass(name);
+  }
+  return(class_);
+};
+
+
+//--------------------------------------------------------------------
+  BClass* BClass::PredeclareNewClass(
      const BText& name,
      BClass*& old,
@@ -1671 +1923 @@
 //--------------------------------------------------------------------
 {
-  old = NULL;
+  old = BClass::GetClassIfExist(name);
   BClass* class_ = NULL;
-  if(name.HasName())
-  {
-    old = FindClass(name,-1);
-    //Checking existent class with the same name
-    if(old && old->isDefined_)
-    {
-      ok = false;
-      Error(BText("Class '") + name +
-        I2("' is already defined as ",
-           "' ya fue definida como \"") + old->Dump() + "\"\n");
-    }
-    else if(old) 
-    {
-      class_ = old;
-    }
-    else
-    {
-      class_ = new BClass(name);
-    }
+  //Checking existent class with the same name
+  if(old && old->isDefined_)
+  {
+    ok = false;
+    Error(BText("Class '") + name +
+      I2("' is already defined as ",
+         "' ya fue definida como \"") + old->Dump() + "\"\n");
+  }
+  else if(old) 
+  {
+    class_ = old;
+  }
+  else
+  {
+    class_ = new BClass(name);
   }
   return(class_);
@@ -1697 +1945 @@
 
 //--------------------------------------------------------------------
-  BClass* BClass::PredeclareClass(const BText& name)
-//--------------------------------------------------------------------
-{
-  BClass* old;
+  BClass* BClass::PredeclareNewClass(const BText& name)
+//--------------------------------------------------------------------
+{
+  BClass* class_;
   bool ok;
-  return(PredeclareClass(name, old, ok));
+  return(PredeclareNewClass(name, class_, ok));
 };
 
@@ -1733 +1981 @@
     {
       name = tok->Name();
-      class_ = PredeclareClass(name, old, ok);
+      class_ = PredeclareNewClass(name, old, ok);
       ok = (class_!=NULL);
       memberLst=NULL;
@@ -1742 +1990 @@
       tok = (BToken*)((List*)(cdr->car()))->car();
       name = tok->Name();
-      class_ = PredeclareClass(name, old, ok);
+      class_ = PredeclareNewClass(name, old, ok);
       ok = (class_!=NULL);
       cdr = cdr->cdr();
@@ -1824 +2072 @@
       //Class without inheriting clause
       name = tok->Name();
-      class_ = PredeclareClass(name, old, ok);
+      class_ = PredeclareNewClass(name, old, ok);
       ok = (class_!=NULL);
       memberLst = cdr;
@@ -1869 +2117 @@
 }
 
-//--------------------------------------------------------------------
-static BClass* FindClassInNameBlock(
-  const BText& name,
-  BUserNameBlock*& unb )
-//--------------------------------------------------------------------
-{
-  BClass* cls = NULL;
-  BSyntaxObject* obj;
-  int pos = name.Find("::",0);
-  if(pos>=0)
-  {
-    BText prefix;
-    BText suffix;
-    prefix = name.SubString(0,pos-1);
-    suffix  = name.SubString(pos+2,name.Length());
-    if(!unb)
-    {
-      obj = GraNameBlock()->FindOperand(prefix,false);
-      if(obj && obj->Grammar()==GraNameBlock())
-      {
-        unb = (BUserNameBlock*)obj;
-      }
-    }
-    else
-    {
-      BNameBlock& nb = unb->Contens();
-      obj = nb.Member(prefix);
-      if(obj && obj->Grammar()==GraNameBlock())
-      {
-        unb = (BUserNameBlock*)obj;
-      }
-      else
-      {
-        unb = NULL;
-      }
-    }
-    if(unb) 
-    {
-      cls = FindClassInNameBlock(suffix, unb);         
-    }
-  }
-  else if(unb)
-  {
-    BNameBlock& nb = unb->Contens();
-    obj = nb.Member(name);
-    if(obj && obj->Mode()==BCLASSMODE)
-    {
-      cls = (BClass*)obj;
-    }
-  }
-  return(cls); 
-}
-
-//--------------------------------------------------------------------
-BClass* FindClass(const BText& name, int defined)
-
-/*! Searches a user class wich name is name and returns it.
- *  If itsn't exists returns NIL.
- */
-//--------------------------------------------------------------------
-{
-  BSyntaxObject* result = NULL;
-  BUserNameBlock* unb = NULL;
-  BClass* cls = FindClassInNameBlock(name, unb);
-  if(!cls && BNameBlock::Current())
-  {
-    result = BNameBlock::Current()->Member(name);
-    if(result && (result->Mode()==BCLASSMODE))
-    {
-      cls = (BClass*)result;
-    }
-  }
-  if(!cls)
-  {
-    cls = BStackManager::FindClass(name);
-  }
-  if(!cls)
-  {
-    result = BNameBlock::LocalMember(name);
-    if(result && (result->Mode()==BCLASSMODE))
-    {
-      cls = (BClass*)result;
-    }
-  }
-  if(!cls) 
-  {
-    BObjClassify oc(GraAnything(),BCLASSMODE);
-    cls= (BClass*)BGrammar::SymbolTable().Search(oc, name);
-  }
-  if(!cls) 
-  {
-    result = BNameBlock::UsingMember(name);
-    if(result && (result->Mode()==BCLASSMODE))
-    {
-      cls = (BClass*)result;
-    }
-  }
-  if(cls && (defined>=0) && (cls->isDefined_!=(defined!=0)))
-  {
-    cls = NULL;
-  }
-  return(cls);
-}
 
 //--------------------------------------------------------------------

tol/btol/bgrammar/oprimp.cpp

@@ -1354 +1354 @@
           {
             BNameBlock& nb = ((BUserNameBlock*)var)->Contens();
+            if(cls->Name()=="@BsrMaster")
+              printf(""); 
                         if(!nb.IsInstanceOf(cls)) 
             {
                                 BText bText = BParser::Unparse(b);
+              BText but = "";
+              if(nb.Class())
+              {
+                but = I2(" but it's an instance of ",
+                         " sino de " )+nb.Class()->FullName();
+              }
+              else
+              {
+                but = I2(" nor any other class.",
+                         " ni de ninguna otra clase.");
+              } 
                                 Error(bText + I2(" is not a NameBlock instance of ",
                                                              " no es un NameBlock instancia de ") +
-                                      cls->FullName());
+                                      cls->FullName()+but);
                                 DESTROY(var);
                         } 
@@ -1599 +1612 @@
     BStruct*  str  = NIL;
     BClass*   cls  = NIL;
+    structs_ [n] = NIL;
+    classes_ [n] = NIL;
     bool carIsList = dec->car()->IsListClass();
     List* decLst = carIsList?Tree::treNode((List*) dec):(List*)dec;
@@ -1614 +1629 @@
       structs_ [n] = str;
       classes_ [n] = cls;
+      if(str) { str->IncNRefs(); }
+      if(cls) { cls->IncNRefs(); }
       dec = dec->cdr();
     } 
@@ -1875 +1892 @@
   declare_     = "";
   define_      = "";
+  for(int n = 0; n<maxArg_; n++)
+  {
+    if(classes_[n]) { classes_[n]->DecNRefs(); }
+    if(structs_[n]) { structs_[n]->DecNRefs(); }
+  }
 }
 

tol/btol/bgrammar/spfuninst.cpp

@@ -137 +137 @@
                    int numParam)
     
-/*! Returns true if the number of branch in a tree is correct
+/*! Returns true if the number and types of branches in a tree is correct
  */
 //--------------------------------------------------------------------
@@ -143 +143 @@
   BList* lst = NIL;
   BList* aux = NIL;
-  BInt n = BSpecialFunction::NumBranches(tre);
-  if(numParam)
-  {
-    for(BInt i=0; i<n; i++)
-    {
-      BInt j = Minimum(i, numParam-1);
-      BGrammar* gra = graParam[j];
-      assert(gra);
-      List* branch = Branch(tre,i+1);
-      assert(branch);
-      BSyntaxObject* arg = gra->EvaluateTree(branch);
-      if(arg)
-      {
-        LstFastAppend(lst,aux,arg);
-      }
-      else
-      {
-        Error(BParser::Unparse(branch)+
-              I2(BText(" is not a ") + gra->Name() + " object.",
-              BText(" no es un objeto de tipo ") + gra->Name()));
-        DESTROY(lst);
-        break;
-      }
+  BInt n = numParam;
+  for(BInt i=0; i<n; i++)
+  {
+    BInt j = Minimum(i, numParam-1);
+    BGrammar* gra = graParam[j];
+    assert(gra);
+    List* branch = Branch(tre,i+1);
+    assert(branch);
+    BSyntaxObject* arg = gra->EvaluateTree(branch);
+    if(arg && ((gra==GraAnything()) || (arg->Grammar()==gra)))
+    {
+      LstFastAppend(lst,aux,arg);
+    }
+    else
+    {
+      Error(BParser::Unparse(branch)+
+            I2(BText(" is not a ") + gra->Name() + " object.",
+            BText(" no es un objeto de tipo ") + gra->Name()));
+      DESTROY(lst);
+      return;
     }
   }
@@ -519 +516 @@
 {
   static BText _name_ = "Group";
-  static BGrammar* graParam[2] = 
+  static BGrammar* graParam[3] = 
   { 
     GraText(),
-    GraSet()
+    GraSet(),
+    GraAnything()
   };
-  BSet args; BSpecialFunction::GetArg(args, tre, graParam, 2);
   BSyntaxObject* result = NIL;
-  BSyntaxObject* uTxt  = NIL;
-  BSyntaxObject* uSet  = NIL;
-  if(gra==GraAnything())
-  {
-    Error(I2("Cannot eval Group returning an object of type Anything.",
-             "No se puede evaluar Group para devolver un objeto de tipo Anything."));
-  }
-  else
-  {
-    if(args.Card()>=2)
-    {
-            uTxt = args[1];
-            uSet = args[2];
-      
-            if(uTxt && uSet)
-            {
+
+  BInt nb = BSpecialFunction::NumBranches(tre);
+  BSet args; 
+  if(BSpecialFunction::TestNumArg(_name_, 2, nb, 3))
+  {  
+    BSpecialFunction::GetArg(args, tre, graParam, nb);
+  }
+  if(args.Card()==nb)
+  {
+    BSyntaxObject* uTxt  = NIL;
+    BSyntaxObject* uSet  = NIL;
+    if(gra==GraAnything())
+    {
+      Error(I2("Cannot eval Group returning an object of type Anything.",
+               "No se puede evaluar Group para devolver un objeto de tipo Anything."));
+    }
+    else
+    {
+      uTxt = args[1];
+      uSet = args[2];
+      if(uTxt && uSet)
+      {
         BSet& set = Set(uSet);
-              BText txt = uTxt->Dump();
-                                txt = txt.SubString(1,txt.Length()-2);
-              BStandardOperator* ope = (BStandardOperator*)gra->FindOperator(txt);
-              if(ope)
-              {
-                      if(set.Card()==0) 
+        BText txt  = uTxt->Dump();
+        txt = txt.SubString(1,txt.Length()-2);
+        BStandardOperator* ope = (BStandardOperator*)gra->FindOperator(txt);
+        if(ope)
+        {
+          if(set.Card()==0) 
           {
-            if(args.Card()==3)
+            if(nb==3)
             {
-                    result = args[3];
+              if(gra==args[3]->Grammar()) { result = gra->New("",args[3]); }
+              else
+              {
+                Error(I2("Group default value type should be ",
+                         "El valor por defecto de Group debería ser de tipo ")+gra->Name()+
+                      I2(" instead of "," en lugar de ")+args[3]->Grammar()->Name());
+              }
             }
             else
@@ -558 +567 @@
               Error(I2("Cannot evaluate Group over empty set without "
                        "a default value.",
-                                               "No sepuede evaluar Group sobre un conjunto vacío "
+                       "No se puede evaluar Group sobre un conjunto vacío "
                        "sin valor por defecto."));
             }
@@ -564 +573 @@
           else  
           {
-                        BBool ok = BTRUE;
+            BBool ok = BTRUE;
             BGrammar* g;
-                        for(BInt n=1; ok&&(n<=set.Card()); n++) 
+            for(BInt n=1; ok&&(n<=set.Card()); n++) 
             {
               g = set[n]->Grammar();
-                                if((gra!=GraAnything()) && 
-                                   !(ok = (g==gra))) 
+              if((gra!=GraAnything()) && 
+                 !(ok = (g==gra))) 
               {
-                                  Error(I2("An element for Group function is not an"
-                                                 " object of type ",
-                                                 "Algún elemento para la funcion Group no"
+                Error(I2("An element for Group function is not an"
+                         " object of type ",
+                         "Algún elemento para la funcion Group no"
                          " es un objeto de tipo ")+ gra->Name()+":\n"+
                          set[n]->LexInfo());
-                                }
-                        }
-                        if(ok) 
+              }
+            }
+            if(ok) 
             {
-                                if(set.Card()==1) 
+              if(set.Card()==1) 
               {
-                                  result = gra->New("",set[1]);
+                result = gra->New("",set[1]);
               //result = set[1];
-                                } 
+              } 
               else 
               {
@@ -591 +600 @@
                 BList* arg = Set(args[2]).ToReversedList();
               //Std(BText("\nGroup(")+uTxt->Dump()+",[["+set.Name()+"]])");
-                                  result = ope->Evaluator(arg);
-                                }
-                        }
-                      }
-              }
-              else
-              {
-                      Error(BText("Group : ") +txt +
-                            I2(" is not a " + gra->Name() + " operator.",
-                                  " no es un operador de tipo " + gra->Name()));
-              }
-            }
+                result = ope->Evaluator(arg);
+              }
+            }
+          }
+        }
+        else
+        {
+          Error(BText("Group : ") +txt +
+                I2(" is not a " + gra->Name() + " operator.",
+                " no es un operador de tipo " + gra->Name()));
+        }
+      }
     }
   }
@@ -1998 +2007 @@
           unb = (BUserNameBlock*)result;
         }
-        if(!unb || (unb->Contens().Class()!=cls))
+        const BClass* unbCls = (!unb)?NULL:unb->Contens().Class();
+        if(!unb || !unbCls->InheritesFrom(cls))
         {
           errMsg = I2("It was expected an instance of Class ",

tol/btol/bgrammar/tol_bclass.h

@@ -34 +34 @@
 class TOL_API BMemberOwner;
 class TOL_API BClass;
+class TOL_API BStruct;
 struct TOL_API BMbrNum;
 
@@ -63 +64 @@
   int      position_; //Appearing order
 };
+
 
 //--------------------------------------------------------------------
@@ -83 +85 @@
   BSyntaxObject* static_;       //!< Store for Class static member or method
   BText          description_;  //!< Store for Class member description
+  BGrammar*      type_;
+  BStruct*       struct_;
+  BClass*        class_;
  public:
   // Constructors and destructors: bgrammar\class.cpp
@@ -102 +107 @@
   int BuildMethod();
   int BuildStatic();
+  int BuildType();
+  int BuildAll();
         BText   Dump () const;
   void PutDescription(const BText& desc);
@@ -246 +253 @@
   bool DestroyInstance(BNameBlock* instance);
   //! Evaluates a parsed tree with a Class declaration
-  static BClass* PredeclareClass(const BText&name, BClass*&old, bool &ok);
-  static BClass* PredeclareClass(const BText&name);
+  static BClass* GetClassIfExist(const BText& name);
+  static BClass* PredeclareClassIfNeeded(const BText& name);
+  static BClass* PredeclareNewClass(const BText&name, BClass*&old, bool &ok);
+  static BClass* PredeclareNewClass(const BText&name);
   static BSyntaxObject* Evaluate(const List* tree);
   BSyntaxObject* FindMethod(const BText& memberName, bool fullAccess) const;