Changeset 15936a6d in tol

Timestamp:

Sep 1, 2009, 8:33:24 AM (17 years ago)

Author:

Víctor de Buen <vdebuen@…>

Branches:

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

Children:

8cf5460

Parents:

992be58

Message:

Adding static members and methods to classes
Forward declarations of classes

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

File:

• tol/btol/bgrammar/class.cpp (modified) (13 diffs)

tol/btol/bgrammar/class.cpp

@@ -35 +35 @@
 #include <tol/tol_blanguag.h>
 #include <tol/tol_bnameblock.h>
+#include <tol/tol_bcodgra.h>
+
 
 //--------------------------------------------------------------------
@@ -42 +44 @@
 BTraceInit("class.cpp");
 const BClass* BClass::currentClassBuildingInstance_ = NULL;
+const BClass* BClass::currentStatic_ = NULL;
 
 //--------------------------------------------------------------------
@@ -95 +98 @@
   BCore* car;
   parent_ = parent;
-  BToken* tok = (BToken*)branch->car();
   isGood_ = true;
-  if((tok->TokenType()==MONARY)&&(tok->Name()=="static"))
+  BToken* tok = NULL;
+  if(parent && branch && branch->car())
+  {
+    tok = (BToken*)branch->car();
+  }
+  else
+  {
+    isGood_ = false;
+  }
+  if(isGood_ && (tok->TokenType()==MONARY) && (tok->Name()=="Static"))
   {
     isStatic_ = true;
-    branch_ = branch = branch->cdr();
-  }
-  if((tok->TokenType()==BINARY)&&(tok->Name()=="="))
-  {
-  //If is a '=' expression then is not a method and has default value
-    isMethod_ = false;
-    BText expression = BParser::Unparse(branch,"","");
-    if(expression[0]=='[')
-    {
-      expression = expression.SubString(2,expression.Length()-3);
-    }
-    else if(expression[0]=='{')
-    {
-      expression = expression.SubString(1,expression.Length()-2);
-    }
-    int posEq = expression.Find("=");
-    int posSp = expression.Find(" ");
-    name_ = expression.SubString(posSp+1,posEq-1);
-    declaration_ = expression.SubString(0,posEq-1);
-    definition_ = expression.SubString(posEq+1,expression.Length());
-  }
-  else if((tok->TokenType()==BINARY)&&(tok->Name()=="#F#"))
-  {
-  //If is a '#F#' expression then is a method and has default value
-    isMethod_ = true;
-    cdr = branch->cdr();
-    if(cdr)
-    {
-      car = cdr->car();
-      if(car && car->IsListClass())
-      {
-        declaration_ = BParser::Unparse((List*)car,"","");
-        if(((List*)car)->cdr() && 
-           ((List*)car)->cdr()->car() &&
-           ((List*)car)->cdr()->car()->IsListClass())
+    if(!(branch = branch->cdr()))
+    {
+      isGood_ = false;
+    }
+    else 
+    {
+      if(branch->car()->IsListClass())
+      {
+        branch = ((List*)branch->car());
+      }
+      else
+      { 
+        isGood_ = false;
+      }
+    }
+    if(isGood_)
+    {
+      tok = (BToken*)branch->car();
+    }
+    branch_ = branch;
+  }
+  if(isGood_)
+  {
+    if((tok->TokenType()==BINARY)&&(tok->Name()=="="))
+    {
+    //If is a '=' expression then is not a method and has default value
+      isMethod_ = false;
+      BText expression = BParser::Unparse(branch,"","");
+      if(expression[0]=='[')
+      {
+        expression = expression.SubString(2,expression.Length()-3);
+      }
+      else if(expression[0]=='{')
+      {
+        expression = expression.SubString(1,expression.Length()-2);
+      }
+      int posEq = expression.Find("=");
+      int posSp = expression.Find(" ");
+      name_ = expression.SubString(posSp+1,posEq-1);
+      declaration_ = expression.SubString(0,posEq-1);
+      definition_ = expression.SubString(posEq+1,expression.Length());
+    }
+    else if((tok->TokenType()==BINARY)&&(tok->Name()=="#F#"))
+    {
+    //If is a '#F#' expression then is a method and has default value
+      isMethod_ = true;
+      cdr = branch->cdr();
+      if(cdr)
+      {
+        car = cdr->car();
+        if(car && car->IsListClass())
         {
-          car = ((List*)((List*)car)->cdr()->car())->car();
-          tok = (BToken*)car;
-          name_ = tok->Name();
-          cdr = cdr->cdr();
-          if(cdr)
+          declaration_ = BParser::Unparse((List*)car,"","");
+          if(((List*)car)->cdr() && 
+             ((List*)car)->cdr()->car() &&
+             ((List*)car)->cdr()->car()->IsListClass())
           {
-            car = cdr->car();
-            if(car && car->IsListClass())
+            car = ((List*)((List*)car)->cdr()->car())->car();
+            tok = (BToken*)car;
+            name_ = tok->Name();
+            cdr = cdr->cdr();
+            if(cdr)
             {
-              definition_  = BParser::Unparse((List*)car,"","");
-            }
-            else
-            {
-              isGood_ = false;
+              car = cdr->car();
+              if(car && car->IsListClass())
+              {
+                definition_  = BParser::Unparse((List*)car,"","");
+              }
+              else
+              {
+                isGood_ = false;
+              }
             }
           }
@@ -155 +188 @@
       }
     }
-  }
-  else if(tok->TokenType()==TYPE)
-  {
-  //If is a 'Type name ...' expression then hasn't default value
-    declaration_ = BParser::Unparse(branch,"","");
-    car = branch->cdr()->car();
-    car = (car->IsListClass())?((List*)car)->car():car;
-    tok = (BToken*)car;
-    name_ = tok->Name();
-  //If main token is FUNCTION then member is a method
-    isMethod_ = tok->TokenType()==FUNCTION;
-  }
-  else if((tok->TokenType()==BINARY)&&(tok->Name()=="::"))
-  {
-    declaration_ = BParser::Unparse(branch,"","");
-    BText simpleDec = declaration_;
-    isMethod_ = simpleDec.Find('(')>=0;
-    simpleDec.Replace("("," ");
-    simpleDec.Compact();
-    int p0 = simpleDec.Find(' ');
-    if(p0>0)
-    {
-      int p1 = simpleDec.Find(' ', p0+1);
-      if(p1<0) { p1 = simpleDec.Length()+1; }
-      if(p0+1<p1-1)
-      {
-        name_ = simpleDec.SubString(p0+1,p1-1);
-      }
-    }
-  } 
-  //Cleaning open and close parenthesis
-  if(declaration_[0]=='{')
-  {
-    declaration_=declaration_.SubString(1,declaration_.Length()-2);
+    else if(tok->TokenType()==TYPE)
+    {
+    //If is a 'Type name ...' expression then hasn't default value
+      declaration_ = BParser::Unparse(branch,"","");
+      car = branch->cdr()->car();
+      car = (car->IsListClass())?((List*)car)->car():car;
+      tok = (BToken*)car;
+      name_ = tok->Name();
+    //If main token is FUNCTION then member is a method
+      isMethod_ = tok->TokenType()==FUNCTION;
+    }
+    else if((tok->TokenType()==BINARY)&&(tok->Name()=="::"))
+    {
+      declaration_ = BParser::Unparse(branch,"","");
+      BText simpleDec = declaration_;
+      isMethod_ = simpleDec.Find('(')>=0;
+      simpleDec.Replace("("," ");
+      simpleDec.Compact();
+      int p0 = simpleDec.Find(' ');
+      if(p0>0)
+      {
+        int p1 = simpleDec.Find(' ', p0+1);
+        if(p1<0) { p1 = simpleDec.Length()+1; }
+        if(p0+1<p1-1)
+        {
+          name_ = simpleDec.SubString(p0+1,p1-1);
+        }
+      }
+    } 
+    //Cleaning open and close parenthesis
+    if(declaration_[0]=='{')
+    {
+      declaration_=declaration_.SubString(1,declaration_.Length()-2);
+    }
   }
   //Checking mandatory information: name and declaration. 
   //Definition is optional
-  if(!name_.HasName() || !declaration_.HasName())
+  if(!isGood_ || !name_.HasName() || !declaration_.HasName())
   {
     isGood_ = false;
     Error(I2("Wrong syntax in member declaration ",
              "Sintaxis incorrecta en declaración de miembro ")+
-          BParser::Unparse(branch,"","\n")+
+          BParser::Unparse(branch_,"","\n")+
           I2(" of Class ", "de Class ")+parent->getName());
   }
@@ -249 +282 @@
 //--------------------------------------------------------------------
 {
-  if(!method_ && isMethod_ && definition_.HasName())
+  if(!isStatic_ && !method_ && isMethod_ && definition_.HasName())
   {
     BGrammar::IncLevel();
@@ -293 +326 @@
     {
       static_ = obj;
+      if(isMethod_)
+      {
+        if(obj->Mode()==BOBJECTMODE)
+        {
+          obj = UCode(obj)->Contens().Operator();
+        }
+        ((BUserFunction*)obj)->staticOwner_=(const BClass*)parent_;
+      }
       static_->IncNRefs(); 
       return(1);
@@ -950 +991 @@
       class_->PutName(name);
       BGrammar::AddObject(class_);
-      assert(!class_ || FindClass(name,-1));
     }
   }
@@ -1083 +1123 @@
 }
 
+//--------------------------------------------------------------------
+static BClass* FindClassInNameBlock(
+  const BText& name,
+  BUserNameBlock*& unb )
+//--------------------------------------------------------------------
+{
+  BClass* cls = NULL;
+  BSyntaxObject* obj;
+  int pos = name.Find("::",0);
+  if(pos>=0)
+  {
+    BText prefix;
+    BText sufix;
+    prefix = name.SubString(0,pos-1);
+    sufix  = name.SubString(pos+2,name.Length());
+    if(!unb)
+    {
+      obj = GraNameBlock()->FindVariable(prefix);
+      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(sufix, unb);         
+    }
+  }
+  else if(unb)
+  {
+    BNameBlock& nb = unb->Contens();
+    obj = nb.Member(name);
+    if(obj && obj->Mode()==BCLASSMODE)
+    {
+      cls = (BClass*)obj;
+    }
+  }
+  return(cls); 
+}
 
 //--------------------------------------------------------------------
@@ -1093 +1185 @@
 {
   BSyntaxObject* result = NULL;
-  BClass* bcls = BStackManager::FindClass(name);
-  if(!bcls)
+  BUserNameBlock* unb = NULL;
+  BClass* cls = FindClassInNameBlock(name, unb);
+  if(!cls)
+  {
+    cls = BStackManager::FindClass(name);
+  }
+  if(!cls)
   {
     const BNameBlock* cns = BNameBlock::Current();
@@ -1102 +1199 @@
       if(result && (result->Mode()==BCLASSMODE))
       {
-        bcls = (BClass*)result;
+        cls = (BClass*)result;
       }
       if(!result)
@@ -1111 +1208 @@
     }
   }
-  if(!bcls) 
+  if(!cls) 
   {
     BObjClassify oc(GraAnything(),BCLASSMODE);
-    bcls= (BClass*)BGrammar::SymbolTable().Search(oc, name);
-  }
-  if(!bcls) 
+    cls= (BClass*)BGrammar::SymbolTable().Search(oc, name);
+  }
+  if(!cls) 
   {
     result = BNameBlock::UsingMember(name);
     if(result && (result->Mode()==BCLASSMODE))
     {
-      bcls = (BClass*)result;
-    }
-  }
-  if(bcls && (defined>=0) && (bcls->isDefined_!=defined))
-  {
-    bcls = NULL;
-  }
-  return(bcls);
-}
-
-//--------------------------------------------------------------------
-BSyntaxObject* BClass::FindMethod(const BText& memberName) const
+      cls = (BClass*)result;
+    }
+  }
+  if(cls && (defined>=0) && (cls->isDefined_!=defined))
+  {
+    cls = NULL;
+  }
+  return(cls);
+}
+
+//--------------------------------------------------------------------
+static bool checkNonPrivate(
+  const BClass* cls, 
+  const BText& memberName,
+  bool fullAccess) 
+//--------------------------------------------------------------------
+{
+  if(!fullAccess && (memberName[0]=='_')&&(memberName[1]!='.'))
+  {
+    Error(I2("Cannot access to private member ",
+             "No se puede acceder al miembro privado ")+memberName +
+          I2(" of Class ",
+             " de Class ")+cls->Name());
+    return(false);
+  }
+  else
+  {
+    return(true);
+  }
+}
+//--------------------------------------------------------------------
+BSyntaxObject* BClass::FindMethod(const BText& memberName, bool fullAccess) const
 //--------------------------------------------------------------------
 {
   BSyntaxObject* result = NULL;
   BMember* mbr = FindMember(memberName);
-  if(mbr && mbr->method_)
+  if(mbr && mbr->method_ && checkNonPrivate(this, memberName, fullAccess))
   { 
     result = mbr->method_;
@@ -1145 +1262 @@
 
 //--------------------------------------------------------------------
-BSyntaxObject* BClass::FindStaticMethod(const BText& methodName) const
+BSyntaxObject* BClass::FindStaticMethod(const BText& methodName, bool fullAccess) const
 //--------------------------------------------------------------------
 {
   BSyntaxObject* result = NULL;
   BMember* mbr = FindMember(methodName);
-  if(mbr && mbr->isStatic_ && mbr->isMethod_)
+  if(mbr && mbr->isStatic_ && mbr->isMethod_  && 
+     checkNonPrivate(this, methodName, fullAccess))
   { 
-    result = mbr->method_;
+    result = mbr->static_;
+    result->PutNameBlock(NULL);
   } 
   return(result);
@@ -1158 +1277 @@
 
 //--------------------------------------------------------------------
-BSyntaxObject* BClass::FindStaticMemeber(const BText& memberName) const
+BSyntaxObject* BClass::FindStaticMemeber(const BText& memberName, bool fullAccess) const
 //--------------------------------------------------------------------
 {
   BSyntaxObject* result = NULL;
   BMember* mbr = FindMember(memberName);
-  if(mbr && mbr->static_ && !mbr->isMethod_)
+  if(mbr && mbr->static_ && !mbr->isMethod_  && 
+     checkNonPrivate(this, memberName, fullAccess))
   { 
     result = mbr->static_;
+    result->PutNameBlock(NULL);
   } 
   return(result);
 }
 
+//--------------------------------------------------------------------
+BSyntaxObject* BClass::FindStatic(const BText& methodName, bool fullAccess) const
+//--------------------------------------------------------------------
+{
+  BSyntaxObject* result = NULL;
+  BMember* mbr = FindMember(methodName);
+  if(mbr && mbr->isStatic_  && checkNonPrivate(this, methodName, fullAccess))
+  { 
+    result = mbr->static_;
+    result->PutNameBlock(NULL);
+  } 
+  return(result);
+}
+