Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                             P A R . S Y N C                              --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2008, Free Software Foundation, Inc.         --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
-- for  more details.  You should have  received  a copy of the GNU General --
-- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
-- http://www.gnu.org/licenses for a complete copy of the license.          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------
 
separate (Par)
package body Sync is
 
   procedure Resync_Init;
   --  This routine is called on initiating a resynchronization action
 
   procedure Resync_Resume;
   --  This routine is called on completing a resynchronization action
 
   -------------------
   -- Resync_Choice --
   -------------------
 
   procedure Resync_Choice is
   begin
      Resync_Init;
 
      --  Loop till we get a token that terminates a choice. Note that EOF is
      --  one such token, so we are sure to get out of this loop eventually!
 
      while Token not in Token_Class_Cterm loop
         Scan;
      end loop;
 
      Resync_Resume;
   end Resync_Choice;
 
   ------------------
   -- Resync_Cunit --
   ------------------
 
   procedure Resync_Cunit is
   begin
      Resync_Init;
 
      while Token not in Token_Class_Cunit
        and then Token /= Tok_EOF
      loop
         Scan;
      end loop;
 
      Resync_Resume;
   end Resync_Cunit;
 
   -----------------------
   -- Resync_Expression --
   -----------------------
 
   procedure Resync_Expression is
      Paren_Count : Int;
 
   begin
      Resync_Init;
      Paren_Count := 0;
 
      loop
         --  Terminating tokens are those in class Eterm and also RANGE,
         --  DIGITS or DELTA if not preceded by an apostrophe (if they are
         --  preceded by an apostrophe, then they are attributes). In addition,
         --  at the outer parentheses level only, we also consider a comma,
         --  right parenthesis or vertical bar to terminate an expression.
 
         if Token in Token_Class_Eterm
 
           or else (Token in Token_Class_Atkwd
                     and then Prev_Token /= Tok_Apostrophe)
 
           or else (Paren_Count = 0
                     and then
                       (Token = Tok_Comma
                         or else Token = Tok_Right_Paren
                         or else Token = Tok_Vertical_Bar))
         then
            --  A special check: if we stop on the ELSE of OR ELSE or the
            --  THEN of AND THEN, keep going, because this is not really an
            --  expression terminator after all. Also, keep going past WITH
            --  since this can be part of an extension aggregate
 
            if (Token = Tok_Else and then Prev_Token = Tok_Or)
               or else (Token = Tok_Then and then Prev_Token = Tok_And)
               or else Token = Tok_With
            then
               null;
            else
               exit;
            end if;
         end if;
 
         if Token = Tok_Left_Paren then
            Paren_Count := Paren_Count + 1;
 
         elsif Token = Tok_Right_Paren then
            Paren_Count := Paren_Count - 1;
 
         end if;
 
         Scan; -- past token to be skipped
      end loop;
 
      Resync_Resume;
   end Resync_Expression;
 
   -----------------
   -- Resync_Init --
   -----------------
 
   procedure Resync_Init is
   begin
      --  The following check makes sure we do not get stuck in an infinite
      --  loop resynchronizing and getting nowhere. If we are called to do a
      --  resynchronize and we are exactly at the same point that we left off
      --  on the last resynchronize call, then we force at least one token to
      --  be skipped so that we make progress!
 
      if Token_Ptr = Last_Resync_Point then
         Scan; -- to skip at least one token
      end if;
 
      --  Output extra error message if debug R flag is set
 
      if Debug_Flag_R then
         Error_Msg_SC ("resynchronizing!");
      end if;
   end Resync_Init;
 
   ---------------------------
   -- Resync_Past_Semicolon --
   ---------------------------
 
   procedure Resync_Past_Semicolon is
   begin
      Resync_Init;
 
      loop
         --  Done if we are at a semicolon
 
         if Token = Tok_Semicolon then
            Scan; -- past semicolon
            exit;
 
         --  Done if we are at a token which normally appears only after
         --  a semicolon. One special glitch is that the keyword private is
         --  in this category only if it does NOT appear after WITH.
 
         elsif Token in Token_Class_After_SM
            and then (Token /= Tok_Private or else Prev_Token /= Tok_With)
         then
            exit;
 
         --  Otherwise keep going
 
         else
            Scan;
         end if;
      end loop;
 
      --  Fall out of loop with resynchronization complete
 
      Resync_Resume;
   end Resync_Past_Semicolon;
 
   -------------------------
   -- Resync_To_Semicolon --
   -------------------------
 
   procedure Resync_To_Semicolon is
   begin
      Resync_Init;
 
      loop
         --  Done if we are at a semicolon
 
         if Token = Tok_Semicolon then
            exit;
 
         --  Done if we are at a token which normally appears only after
         --  a semicolon. One special glitch is that the keyword private is
         --  in this category only if it does NOT appear after WITH.
 
         elsif Token in Token_Class_After_SM
            and then (Token /= Tok_Private or else Prev_Token /= Tok_With)
         then
            exit;
 
         --  Otherwise keep going
 
         else
            Scan;
         end if;
      end loop;
 
      --  Fall out of loop with resynchronization complete
 
      Resync_Resume;
   end Resync_To_Semicolon;
 
   ----------------------------------------------
   -- Resync_Past_Semicolon_Or_To_Loop_Or_Then --
   ----------------------------------------------
 
   procedure Resync_Past_Semicolon_Or_To_Loop_Or_Then is
   begin
      Resync_Init;
 
      loop
         --  Done if at semicolon
 
         if Token = Tok_Semicolon then
            Scan; -- past the semicolon
            exit;
 
         --  Done if we are at a token which normally appears only after
         --  a semicolon. One special glitch is that the keyword private is
         --  in this category only if it does NOT appear after WITH.
 
         elsif Token in Token_Class_After_SM
           and then (Token /= Tok_Private or else Prev_Token /= Tok_With)
         then
            exit;
 
         --  Done if we are at THEN or LOOP
 
         elsif Token = Tok_Then or else Token = Tok_Loop then
            exit;
 
         --  Otherwise keep going
 
         else
            Scan;
         end if;
      end loop;
 
      --  Fall out of loop with resynchronization complete
 
      Resync_Resume;
   end Resync_Past_Semicolon_Or_To_Loop_Or_Then;
 
   -------------------
   -- Resync_Resume --
   -------------------
 
   procedure Resync_Resume is
   begin
      --  Save resync point (see special test in Resync_Init)
 
      Last_Resync_Point := Token_Ptr;
 
      if Debug_Flag_R then
         Error_Msg_SC ("resuming here!");
      end if;
   end Resync_Resume;
 
   --------------------
   -- Resync_To_When --
   --------------------
 
   procedure Resync_To_When is
   begin
      Resync_Init;
 
      loop
         --  Done if at semicolon, WHEN or IS
 
         if Token = Tok_Semicolon
           or else Token = Tok_When
           or else Token = Tok_Is
         then
            exit;
 
         --  Otherwise keep going
 
         else
            Scan;
         end if;
      end loop;
 
      --  Fall out of loop with resynchronization complete
 
      Resync_Resume;
   end Resync_To_When;
 
   ---------------------------
   -- Resync_Semicolon_List --
   ---------------------------
 
   procedure Resync_Semicolon_List is
      Paren_Count : Int;
 
   begin
      Resync_Init;
      Paren_Count := 0;
 
      loop
         if Token = Tok_EOF
           or else Token = Tok_Semicolon
           or else Token = Tok_Is
           or else Token in Token_Class_After_SM
         then
            exit;
 
         elsif Token = Tok_Left_Paren then
            Paren_Count := Paren_Count + 1;
 
         elsif Token = Tok_Right_Paren then
            if Paren_Count = 0 then
               exit;
            else
               Paren_Count := Paren_Count - 1;
            end if;
         end if;
 
         Scan;
      end loop;
 
      Resync_Resume;
   end Resync_Semicolon_List;
 
end Sync;