Exemplo n.º 1
0
 public void parse(CSsemi.CSemiExp semi)
 {
     foreach (IRule rule in Rules)
       {
     if (rule.test(semi))
       break;
       }
       if(rule.test(semi)!=0)
        Add(rule);
 }
Exemplo n.º 2
0
        public void parse(CSsemi.CSemiExp semi)
        {
            // Note: rule returns true to tell parser to stop
            //       processing the current semiExp

            foreach (IRule rule in Rules)
            {
                //semi.display();
                if (rule.test(semi))
                    break;
            }
        }
Exemplo n.º 3
0
        public void parse(CSsemi.CSemiExp semi, string file)        //file is passed as a parameter to insert the records filewise
        {
            // Note: rule returns true to tell parser to stop
            //       processing the current semiExp

            foreach (IRule rule in Rules)
            {
                //semi.display();
                if (rule.test(semi, file))                  //file is passed as a parameter to insert the records filewise
                    break;
            }
        }
Exemplo n.º 4
0
      public override void doAction(CSsemi.CSemiExp semi)
      {
          TypeModel tm = new TypeModel();
          FileModel fm = new FileModel();
          
       // Console.Write("\n  Entering scope: ");

        if (semi.Contains("class") != -1)
        {
            int index = semi.Contains("class");
           // Console.Write("class: ");
            tm.addType(semi[index + 1], fm.CurrentFile);
            

        }
        else if (semi.Contains("struct") != -1)
        {
            int index = semi.Contains("struct");
            //Console.Write("struct: ");
            tm.addType(semi[index + 1], fm.CurrentFile);
        }
        else if (semi.Contains("interface") != -1)
        {
            int index = semi.Contains("class");
            //Console.Write("interface: ");
            tm.addType(semi[index + 1], fm.CurrentFile);       
        }
        else if (semi.Contains("enum") != -1)
        {
            int index = semi.Contains("class");
            //Console.Write("enum: ");
            tm.addType(semi[index + 1], fm.CurrentFile);
        }
        else if (semi.Contains("delegte") != -1)
        {
            int index = semi.Contains("delegate");
            //Console.Write("delegate: ");
            tm.addType(semi[index + 2], fm.CurrentFile);
        }
        else

            Console.Write("");

        }
 public override void doAction(CSsemi.CSemiExp semi, string filename)
 {
     Console.Write("\n  line# {0}", repo_.semi.lineCount - 1);
     this.display(semi);
 }
        public int indexOfType(CSsemi.CSemiExp semi)
        {
            int indexCL = semi.Contains("class");
              int indexIF = semi.Contains("interface");
              int indexST = semi.Contains("struct");
              int indexEN = semi.Contains("enum");

              int index = Math.Max(indexCL, indexIF);
              index = Math.Max(index, indexST);
              index = Math.Max(index, indexEN);
              return index;
        }
 public abstract void doAction(CSsemi.CSemiExp semi);
        static bool displayStack_ = false;  // default

        public abstract void doAction(CSsemi.CSemiExp semi, string filename);
 abstract public bool test(CSsemi.CSemiExp semi, string filename);
        public override bool test(CSsemi.CSemiExp semi, string filename)
        {
            if (semi[semi.count - 1] != "{")
                return false;
            int index = semi.FindFirst("(");

            List<Elem> table = RepositoryForOutput.storageForOutput_;
            CSsemi.CSemiExp local = new CSsemi.CSemiExp();
            try
            {
                if (index > 0 && !isSpecialToken(semi[index - 1]))
                {
                    for (int i = index - 1; i < semi.count; i++)
                    {
                        foreach (Elem e in table)
                        {
                            if ((e.name.Equals(semi[i])) && !(e.type.Equals("function")) && !(e.type.Equals("namespace")))
                            {
                                local.Add("Using").Add(semi[i]).Add(e.filename).Add(e.namespacename);
                                doActions(local, filename);
                                return false;
                            }
                        }
                    }
                }
            }
            catch
            {
            }
            return false;
        }
        public override bool test(CSsemi.CSemiExp semi, string filename)
        {
            int index = semi.Contains("new");
            try
            {
                if (index != -1)
                {
                    List<Elem> table = RepositoryForOutput.storageForOutput_;
                    foreach (Elem e in table)
                    {
                        if ((e.name.Equals(semi[index + 1])) && !(e.type.Equals("function")) && !semi[index + 1].Equals("List"))
                        {
                            aggregationTest(semi, index, filename,e.filename, e.namespacename);
                            return true;

                        }
                    }
                }
            }
            catch
            {
            }
            return false;
        }
Exemplo n.º 12
0
 public override bool test(CSsemi.CSemiExp semi)
 {
   if (semi.Contains("{") != -1)
     doActions(semi);
   return false;  // don't stop
 }
 public override void doAction(CSsemi.CSemiExp semi, string filename)
 {
     if (semi[0].Equals("complexity"))
     {
         try
         {
             int x = repo_.locations.Count;
             Elem temp = repo_.locations[x - 1];
             if (temp.type.Equals("function"))
                 temp.complexity += 1;
         }
         catch
         {
         }
         return;
     }
     else
     {
         Elem elem = new Elem();
         elem.type = semi[0];  // expects type
         elem.name = semi[1];  // expects name
         elem.begin = repo_.semi.lineCount - 1;
         elem.end = 0;
         elem.filename = filename;
         elem.complexity = 1;
         repo_.stack.push(elem);
         if (elem.type == "control" || elem.name == "anonymous")
             return;
         repo_.locations.Add(elem);
         RepositoryForOutput.storageForOutput_.Add(elem);
         if (AAction.displaySemi)
         {
             Console.Write("\n  line# {0,-5}", repo_.semi.lineCount - 1);
             Console.Write("entering ");
             string indent = new string(' ', 2 * repo_.stack.count);
             Console.Write("{0}", indent);
             this.display(semi); // defined in abstract action
         }
         if (AAction.displayStack)
             repo_.stack.display();
     }
 }
 public override void doAction(CSsemi.CSemiExp semi, string filename)
 {
     this.display(semi);
 }
 public override void display(CSsemi.CSemiExp semi)
 {
     Console.Write("\n    line# {0}", repo_.semi.lineCount - 1);
     Console.Write("\n    ");
     for (int i = 0; i < semi.count; ++i)
         if (semi[i] != "\n" && !semi.isComment(semi[i]))
             Console.Write("{0} ", semi[i]);
 }
 public override bool test(CSsemi.CSemiExp semi, string filename)
 {
     int index = semi.Contains("class");
     try
     {
         if (index != -1)
         {
             foreach (Elem e in table)
             {
                 if (e.name.Equals(semi[index + 1]))
                 {
                     inhertanceTest(semi, index, filename);
                     return false;
                 }
             }
         }
     }
     catch
     {
     }
     return false;
 }
 private void aggregationTest(CSsemi.CSemiExp semi, int index, string filename, string filenameto, string namespacename)
 {
     CSsemi.CSemiExp local = new CSsemi.CSemiExp();
     if ((semi[index + 2].Equals(".")))
     {
         local.Add("Aggregation").Add(semi[index + 3]).Add(semi[index - 2]).Add(filenameto).Add(namespacename);
         doActions(local, filename);
     }
     else
     {
         local.Add("Aggregation").Add(semi[index + 1]).Add(semi[index - 2]).Add(filenameto).Add(namespacename);
         doActions(local, filename);
     }
 }
        public override void doAction(CSsemi.CSemiExp semi, string filename)
        {
            Elem elem = new Elem();
            elem.type = semi[0];  // expects type
            elem.name = semi[1];  // expects name
            elem.filename = filename;
            if (elem.type.Equals("namespace"))
                elem.namespacename = elem.name;
            else
                elem.namespacename = namespacematch();
            //repo_.stack.push(elem);
            repo_.locations.Add(elem);
            if(!elem.type.Equals("namespace"))
            RepositoryForOutput.storageForOutput_.Add(elem);

            if (AAction.displaySemi)
            {
                Console.Write("\n  line# {0,-5}", repo_.semi.lineCount - 1);
                Console.Write("entering ");
                string indent = new string(' ', 2 * repo_.stack.count);
                Console.Write("{0}", indent);
                this.display(semi); // defined in abstract action
            }
            if (AAction.displayStack)
                repo_.stack.display();

        }
 public override bool test(CSsemi.CSemiExp semi, string filename)
 {
     List<Elem> table = RepositoryForOutput.storageForOutput_;
     CSsemi.CSemiExp local = new CSsemi.CSemiExp();
     try
     {
         for (int i = 0; i < semi.count; i++)
         {
             foreach (Elem e in table)
             {
                 if ((e.name.Equals(semi[i])) && ((e.type.Equals("struct")) || (e.type.Equals("enum"))) && !(e.type.Equals("function")) && (semi[i + 2].Equals(";")))
                 {
                     local.Add("Composition").Add(semi[i]).Add(e.filename).Add(e.namespacename);
                     doActions(local, filename);
                     return true;
                 }
             }
         }
     }
     catch
     {
     }
     return false;
 }
 private void inheritance(CSsemi.CSemiExp semi, string filename)
 {
     ElemRelation elem = new ElemRelation();
     elem.filenamefrom = filename;
     elem.namespacefrom = namespacematch();
     elem.definedType = semi[0];
     elem.relationType = semi[1];
     elem.fromName = semi[2];
     elem.toName = semi[3];
     elem.filenameto = semi[4];
     elem.namespaceto = semi[5];
     RepositoryForRelation.storageForRelationship_.Add(elem);
 }
 public BuildCodeAnalyzerRelation(CSsemi.CSemiExp semi)
 {
     repo.semi = semi;
 }
        private void usingRelation(CSsemi.CSemiExp semi, string filename)
        {
            ElemRelation elem = new ElemRelation();
            elem.filenamefrom = filename;
            elem.namespacefrom = namespacematch();
            elem.relationType = semi[0] + "      ";
            elem.toName = semi[1];
            elem.filenameto = semi[2];
            elem.namespaceto = semi[3];

            int x = repo_.locations.Count;
            Elem temp = repo_.locations[x - 1];
            elem.fromName = temp.name;
            elem.definedType = temp.type;

            if (!elem.fromName.Equals(elem.toName))
                RepositoryForRelation.storageForRelationship_.Add(elem);
        }
 public void doActions(CSsemi.CSemiExp semi, string filename)
 {
     foreach (IAction action in actions)
         action.doAction(semi, filename);
 }
 public override void doAction(CSsemi.CSemiExp semi, string filename)
 {
     if (semi[1].Equals("Inheritance")) //Action for Inheritance
     {
         inheritance(semi, filename);
         return;
     }
     if (semi[0].Contains("Aggregation"))
     {
         aggregation(semi, filename);
         return;
     }
     if (semi[0].Contains("Composition"))
     {
         composition(semi, filename);
         return;
     }
     if (semi[0].Contains("Using"))
     {
         usingRelation(semi, filename);
         return;
     }
     if (semi[0].Contains("namespace"))
     {
         Elem ele = new Elem();
         ele.type = semi[0];
         ele.name = semi[1];
         ele.filename = filename;
         repo_.locations.Add(ele);
     }             
     if (semi[0].Contains("class"))
     {
         Elem ele = new Elem();
         ele.type = semi[0];
         ele.name = semi[1];
         ele.filename = filename;
         repo_.locations.Add(ele);
     }
     if (AAction.displaySemi)
     {
         Console.Write("\n  line# {0,-5}", repo_.semi.lineCount - 1);
         Console.Write("entering ");
         string indent = new string(' ', 2 * repo_.stack.count);
         Console.Write("{0}", indent);
         this.display(semi); // defined in abstract action
     }
     if (AAction.displayStack)
         repo_.stack.display();
 }
 public virtual void display(CSsemi.CSemiExp semi)
 {
     if(displaySemi)
     for (int i = 0; i < semi.count; ++i)
       Console.Write("{0} ", semi[i]);
 }
 public override bool test(CSsemi.CSemiExp semi, string filename)
 {
     int index = semi.Contains("delegate");
     if (index != -1)
     {
         CSsemi.CSemiExp local = new CSsemi.CSemiExp();
         // create local semiExp with tokens for type and name
         local.displayNewLines = false;
         local.Add(semi[index]).Add(semi[index + 2]);
         doActions(local, filename);
         return true;
     }
     return false;
 }
 public void doActions(CSsemi.CSemiExp semi)
 {
     foreach (IAction action in actions)
     action.doAction(semi);
 }
        public override bool test(CSsemi.CSemiExp semi, string filename)
        {
            int indexCL = semi.Contains("class");
            int indexIF = semi.Contains("interface");
            int indexST = semi.Contains("struct");
            int indexEN = semi.Contains("enum");

            int index = Math.Max(indexCL, indexIF);
            index = Math.Max(index, indexST);
            index = Math.Max(index, indexEN);
            if (index != -1)
            {
                CSsemi.CSemiExp local = new CSsemi.CSemiExp();
                // local semiExp with tokens for type and name
                local.displayNewLines = false;
                local.Add(semi[index]).Add(semi[index + 1]);
                doActions(local, filename);
                return true;
            }
            return false;
        }
 public abstract bool test(CSsemi.CSemiExp semi);
        private void inhertanceTest(CSsemi.CSemiExp semi, int index, string filename)
        {
            CSsemi.CSemiExp local = new CSsemi.CSemiExp();
            CSsemi.CSemiExp local1 = new CSsemi.CSemiExp();
            local.displayNewLines = false;
            local1.displayNewLines = false;

            if ((semi[index + 2].Equals(":")))
            {
                foreach (Elem check in table)
                {
                    if (check.name.Equals(semi[index + 3]))
                    {
                        local.Add(semi[index]).Add("Inheritance").Add(semi[index + 1]).Add(semi[index + 3]).Add(check.filename).Add(check.namespacename);
                        doActions(local, filename);
                        break;
                    }
                }
            }
            if ((semi[index + 2].Equals(":")) && (semi[index + 4].Equals(",")))
            {
                foreach (Elem check in table)
                {
                    if (check.name.Equals(semi[index + 5]))
                    {
                        local1.Add(semi[index]).Add("Inheritance").Add(semi[index + 1]).Add(semi[index + 5]).Add(check.filename).Add(check.namespacename);
                        doActions(local1, filename);
                        break;
                    }
                }
            }
        }