-- Copyright (c) 1990 Regents of the University of California.
-- All rights reserved.
--
-- This software was developed by John Self of the Arcadia project
-- at the University of California, Irvine.
--
-- Redistribution and use in source and binary forms are permitted
-- provided that the above copyright notice and this paragraph are
-- duplicated in all such forms and that any documentation,
-- advertising materials, and other materials related to such
-- distribution and use acknowledge that the software was developed
-- by the University of California, Irvine.  The name of the
-- University may not be used to endorse or promote products derived
-- from this software without specific prior written permission.
-- THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
-- IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-- WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

-- TITLE template manager
-- AUTHOR: John Self (UCI)
-- DESCRIPTION supports output of internalized templates for the IO and DFA
--             packages.
-- NOTES This package is quite a memory hog, and is really only useful on
--       virtual memory systems.  It could use an external file to store the
--       templates like the skeleton manager.  This would save memory at the
--       cost of a slight reduction in speed and the necessity of keeping
--       copies of the template files in a known place.
-- $Header: /dc/uc/self/arcadia/aflex/ada/src/RCS/template_managerB.a,v 1.21 1992/12/29 22:46:15 self Exp self $

with Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO;
with Ada.Wide_Wide_Text_IO;

with MISC_DEFS, EXTERNAL_FILE_MANAGER, MISC;
use MISC_DEFS;

package body Template_Manager is

   use Ada.Strings.Wide_Wide_Unbounded;
   use Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO;
   use Ada.Wide_Wide_Text_IO;

   type File_Array is array (Positive range <>) of Unbounded_Wide_Wide_String;

   function "+" (Item : Wide_Wide_String) return Unbounded_Wide_Wide_String
     renames To_Unbounded_Wide_Wide_String;

   DFA_Template : constant File_Array :=
     (
--  DFA TEMPLATE START
+"",
+"   YYText_Ptr : Integer; -- points to start of yytext in buffer",
+"",
+"   --  yy_ch_buf has to be 2 characters longer than YY_BUF_SIZE because we",
+"   --  need to put in 2 end-of-buffer characters (this is explained where",
+"   --  it is done) at the end of yy_ch_buf",
+"   YY_READ_BUF_SIZE : constant Integer := 8192;",
+"   YY_BUF_SIZE      : constant Integer := YY_READ_BUF_SIZE * 2;",
+"   --  Size of input buffer",
+"",
+"   type Unbounded_Character_Array is",
+"     array (Integer range <>) of Wide_Wide_Character;",
+"",
+"   type Ch_Buf_Type is record",
+"      Data : Unbounded_Character_Array (0 .. YY_BUF_SIZE + 1);",
+"   end record;",
+"",
+"   function Previous",
+"     (Data : Ch_Buf_Type; Index : Integer) return Wide_Wide_Character;",
+"   procedure Next",
+"     (Data  : Ch_Buf_Type;",
+"      Index : in out Integer;",
+"      Code  : out Wide_Wide_Character);",
+"",
+"   YY_Ch_Buf : Ch_Buf_Type;",
+"   YY_CP     : Integer;",
+"   YY_BP     : Integer;",
+"",
+"   YY_C_Buf_P : Integer;  --  Points to current character in buffer",
+"",
+"   function YYText return Wide_Wide_String;",
+"   function YYLength return Integer;",
+"   procedure YY_DO_BEFORE_ACTION;",
+"",
+"   --  These variables are needed between calls to YYLex.",
+"",
+"   YY_Init  : Boolean := True;  --  do we need to initialize YYLex?",
+"   YY_Start : Integer := 0;     -- current start state number",
+"   subtype YY_State_Type is Integer;",
+"   YY_Last_Accepting_State : YY_State_Type;",
+"   YY_Last_Accepting_Cpos  : Integer;",
+"",
+"%%",
+"",
+"   function YYText return Wide_Wide_String is",
+"      Aux : constant Wide_Wide_String (1 .. YY_CP - YY_BP)",
+"        := Wide_Wide_String (YY_Ch_Buf.Data (YY_BP .. YY_CP - 1));",
+"",
+"   begin",
+"      return Aux;",
+"   end YYText;",
+"",
+"   --  returns the length of the matched text",
+"   function YYLength return Integer is",
+"   begin",
+"      return YY_CP - YY_BP;",
+"   end YYLength;",
+"",
+"   --  done after the current pattern has been matched and before the",
+"   --  corresponding action - sets up yytext",
+"",
+"   procedure YY_DO_BEFORE_ACTION is",
+"   begin",
+"      YYText_Ptr := YY_BP;",
+"      YY_C_Buf_P := YY_CP;",
+"   end YY_DO_BEFORE_ACTION;",
+"",
+"   function Previous",
+"     (Data : CH_Buf_Type; Index : Integer) return Wide_Wide_Character",
+"   is",
+"      Aux : constant Integer := Index - 1;",
+"",
+"   begin",
+"      return Data.Data (Aux);",
+"   end Previous;",
+"",
+"   procedure Next",
+"     (Data  : CH_Buf_Type;",
+"      Index : in out Integer;",
+"      Code  : out Wide_Wide_Character) is",
+"   begin",
+"      Code := Data.Data (Index);",
+"      Index := Index + 1;",
+"   end Next;"
--  DFA TEMPLATE END
);

   DFA_Current_Line : Integer := 1;

   IO_Template : constant File_Array :=
    (
--  IO TEMPLATE START
+"with Ada.Characters.Wide_Wide_Latin_1;",
+"with Ada.Wide_Wide_Text_IO;",
+"",
+"%%",
+"",
+"   User_Input_File  : Ada.Wide_Wide_Text_IO.File_Type;",
+"   User_Output_File : Ada.Wide_Wide_Text_IO.File_Type;",
+"",
+"   Null_In_Input         : exception;",
+"   Aflex_Internal_Error  : exception;",
+"   Unexpected_Last_Match : exception;",
+"   Pushback_Overflow     : exception;",
+"   Aflex_Scanner_Jammed  : exception;",
+"",
+"   type EOB_Action_Type is",
+"     (EOB_ACT_RESTART_SCAN,",
+"      EOB_ACT_END_OF_FILE,",
+"      EOB_ACT_LAST_MATCH);",
+"",
+"   YY_END_OF_BUFFER_CHAR : constant Wide_Wide_Character :=",
+"     Ada.Characters.Wide_Wide_Latin_1.NUL;",
+"   yy_n_chars : integer;       --  number of characters read into yy_ch_buf",
+"",
+"   --  true when we've seen an EOF for the current input file",
+"   yy_eof_has_been_seen : boolean;",
+"",
+"-- UMASS CODES :" ,
+"   --   In order to support YY_Get_Token_Line, we need",
+"   --   a variable to hold current line.",
+"   type String_Ptr is access Wide_Wide_String;",
+"",
+"   Saved_Tok_Line1                : String_Ptr := Null;",
+"   Line_Number_Of_Saved_Tok_Line1 : Integer := 0;",
+"   Saved_Tok_Line2                : String_Ptr := Null;",
+"   Line_Number_Of_Saved_Tok_Line2 : Integer := 0;",
+"",
+"   --  Aflex will try to get next buffer before it processs the",
+"   --  last token. Since now Aflex has been changed to accept",
+"   --  one line by one line, the last token in the buffer is",
+"   --  always end_of_line ( or end_of_buffer ). So before the",
+"   --  end_of_line is processed, next line will be retrieved",
+"   --  into the buffer. So we need to maintain two lines,",
+"   --  which line will be returned in Get_Token_Line is",
+"   --  determined according to the line number. It is the same",
+"   --  reason that we can not reinitialize tok_end_col to 0 in",
+"   --  Yy_Input, but we must do it in yylex after we process the",
+"   --  end_of_line.",
+"",
+"   Tok_Begin_Line       : Integer := 1;",
+"   Tok_End_Line         : Integer := 1;",
+"   Tok_End_Col          : Integer := 0;",
+"   Tok_Begin_Col        : Integer := 0;",
+"   Token_At_End_Of_Line : Boolean := False;",
+"   --  Indicates whether or not last matched token is end_of_line.",
+"-- END OF UMASS CODES.",
+"",
+"   procedure YY_Input",
+"     (Buf      : out Unbounded_Character_Array;",
+"      Result   : out Integer;",
+"      Max_Size : Integer);",
+"   function YY_Get_Next_Buffer return EOB_Action_Type;",
+"   procedure YYUnput (c : Wide_Wide_Character; YY_BP: in out Integer);",
+"   procedure Unput (c : Wide_Wide_Character);",
+"   function Input return Wide_Wide_Character;",
+"   procedure Output (c : Wide_Wide_Character);",
+"   function YYWrap return Boolean;",
+"   procedure Open_Input (FName : String);",
+"   procedure Close_Input;",
+"   procedure Create_Output (FName : String := """");",
+"   procedure Close_Output;",
+"",
+"-- UMASS CODES :",
+"   procedure Yy_Get_Token_Line",
+"     (Yy_Line_String : out Wide_Wide_String;",
+"      Yy_Line_Length : out Natural);",
+"   --  Returnes the entire line in the input, on which the currently",
+"   --  matched token resides.",
+"",
+"   function Yy_Line_Number return Natural;",
+"   --  Returns the line number of the currently matched token.",
+"   --  In case a token spans lines, then the line number of the first line",
+"   --  is returned.",
+"",
+"   function Yy_Begin_Column return Natural;",
+"   function Yy_End_Column return Natural;",
+"   --  Returns the beginning and ending column positions of the",
+"   --  currently mathched token. If the token spans lines then the",
+"   --  begin column number is the column number on the first line",
+"   --  and the end columne number is the column number on the last line.",
+"",
+"-- END OF UMASS CODES.",
+"",
+"%%",
+"",
+"   use Ada.Wide_Wide_Text_IO;",
+"",
+"   --  Gets input and stuffs it into 'buf'.  number of characters read, or",
+"   --  YY_NULL is returned in 'result'.",
+"",
+"   procedure YY_Input",
+"     (Buf      : out Unbounded_Character_Array;",
+"      Result   : out Integer;",
+"      Max_Size : integer)",
+"   is",
+"      C   : Wide_Wide_character;",
+"      I   : Integer := 1;",
+"      Loc : Integer := Buf'First;",
+"-- UMASS CODES :",
+"      --    Since buf is an out parameter which is not readable",
+"      --    and saved lines is a string pointer which space must",
+"      --    be allocated after we know the size, we maintain",
+"      --    an extra buffer to collect the input line and",
+"      --    save it into the saved line 2.",
+"      Temp_Line : Wide_Wide_String (1 .. YY_BUF_SIZE + 2);",
+"-- END OF UMASS CODES.",
+"   begin",
+"-- UMASS CODES :",
+"      buf := (others => Ada.Characters.Wide_Wide_Latin_1.NUL);",
+"      --  Move the saved lines forward.",
+"      Saved_Tok_Line1 := Saved_Tok_Line2;",
+"      Line_Number_Of_Saved_Tok_Line1 := Line_Number_Of_Saved_Tok_Line2;",
+"",
+"-- END OF UMASS CODES.",
+"      if Is_Open (User_Input_File) then",
+"         while I <= Max_Size loop",
+"            if End_Of_Line (User_Input_File) then",
+"               --  Ada ate our newline, put it back on the end.",
+"               Buf (Loc) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"               Skip_Line (User_Input_File, 1);",
+"-- UMASS CODES :",
+"               --  We try to get one line by one line. So we return",
+"               --  here because we saw the end_of_line.",
+"               Result := I;",
+"               Temp_Line (I) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"               Saved_Tok_Line2 := new String (1 .. I);",
+"               Saved_Tok_Line2 (1 .. I) := Temp_Line (1 .. I);",
+"               Line_Number_Of_Saved_Tok_Line2 :=",
+"                 Line_Number_Of_Saved_Tok_Line1 + 1;",
+"",
+"               return;",
+"-- END OF UMASS CODES.",
+"",
+"            else",
+"-- UCI CODES CHANGED:",
+"--    The following codes are modified. Previous codes is commented out.",
+"--    The purpose of doing this is to make it possible to set Temp_Line",
+"--    in Ayacc-extension specific codes. Definitely, we can read the character",
+"--    into the Temp_Line and then set the buf. But Temp_Line will only",
+"--    be used in Ayacc-extension specific codes which makes this approach impossible.",
+"               Get (User_Input_File, C);",
+"               Buf (Loc) := C;",
+"--               get(user_input_file, buf(loc));",
+"-- UMASS CODES :",
+"               Temp_Line (I) := C;",
+"-- END OF UMASS CODES.",
+"            end if;",
+"",
+"            Loc := Loc + 1;",
+"            I := I + 1;",
+"         end loop;",
+"      else",
+"         while I <= Max_Size loop",
+"            if end_of_line then",
+"               -- Ada ate our newline, put it back on the end.",
+"               Buf (Loc) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"               Skip_Line (1);",
+"-- UMASS CODES :",
+"               --  We try to get one line by one line. So we return",
+"               --  here because we saw the end_of_line.",
+"               Result := I;",
+"               Temp_Line (I) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"               Saved_Tok_Line2 := new String (1 .. I);",
+"               Saved_Tok_Line2 (1 .. I) := Temp_Line (1 .. I);",
+"               Line_Number_Of_Saved_Tok_Line2 :=",
+"                 Line_Number_Of_Saved_Tok_Line1 + 1;",
+"",
+"               return;",
+"-- END OF UMASS CODES.",
+"%%",
+"",
+"         else",
+"--    The following codes are modified. Previous codes is commented out.",
+"--    The purpose of doing this is to make it possible to set Temp_Line",
+"--    in Ayacc-extension specific codes. Definitely, we can read the character",
+"--    into the Temp_Line and then set the buf. But Temp_Line will only",
+"--    be used in Ayacc-extension specific codes which makes this approach impossible.",
+"           get(c);",
+"           buf(loc) := c;",
+"--         get(buf(loc));",
+"-- UMASS CODES :",
+"           Temp_Line(i) := c;",
+"-- END OF UMASS CODES.",
+"         end if; ",
+"",
+"         loc := loc + 1;",
+"         i := i + 1;",
+"      end loop;",
+"    end if; -- for input file being standard input",
+"",
+"    result := i - 1; ",
+"-- UMASS CODES :",
+"--   Since we get one line by one line, if we",
+"--   reach here, it means that current line have",
+"--   more that max_size characters. So it is",
+"--   impossible to hold the whole line. We",
+"--   report the warning message and continue.",
+"    buf(loc - 1) := Ascii.LF;",
+"    if (is_open(user_input_file)) then",
+"      skip_line(user_input_file, 1);",
+"    else",
+"      skip_line(1);",
+"    end if;",
+"    Temp_Line(i-1) := ASCII.LF;",
+"    Saved_Tok_Line2 := new String ( 1 .. i - 1);",
+"    Saved_Tok_Line2 ( 1 .. i - 1 ) := Temp_Line ( 1 .. i - 1 );",
+"    Line_Number_Of_Saved_Tok_Line2 := Line_Number_Of_Saved_Tok_Line1 + 1;",
+"    Put_Line ( ""Input line """,
+"               & Integer'Image ( Line_Number_Of_Saved_Tok_Line2 )",
+"               & ""has more than """,
+"               & Integer'Image ( max_size )",
+"               & "" characters, ... truncated."" );",
+"-- END OF UMASS CODES.",
+"    exception",
+"        when END_ERROR => result := i - 1;",
+"    -- when we hit EOF we need to set yy_eof_has_been_seen",
+"    yy_eof_has_been_seen := true;",
+"-- UMASS CODES :",
+"--   Processing incomplete line.",
+"        if i /= 1 then",
+"          -- Current line is not empty but do not have end_of_line.",
+"          -- So current line is incomplete line. But we still need",
+"          -- to save it.",
+"          Saved_Tok_Line2 := new String ( 1 .. i - 1 );",
+"          Saved_Tok_Line2 ( 1 .. i - 1 ) := Temp_Line ( 1 .. i - 1 );",
+"          Line_Number_Of_Saved_Tok_Line2 := Line_Number_Of_Saved_Tok_Line1 + 1;",
+"        end if;",
+"-- END OF UMASS CODES.",
+"end YY_INPUT;",
+"",
+"-- yy_get_next_buffer - try to read in new buffer",
+"--",
+"-- returns a code representing an action",
+"--     EOB_ACT_LAST_MATCH - ",
+"--     EOB_ACT_RESTART_SCAN - restart the scanner",
+"--     EOB_ACT_END_OF_FILE - end of file",
+"",
+"function yy_get_next_buffer return eob_action_type is",
+"    dest : integer := 0;",
+"    source : integer := yytext_ptr - 1; -- copy prev. char, too",
+"    number_to_move : integer;",
+"    ret_val : eob_action_type;",
+"    num_to_read : integer;",
+"begin    ",
+"    if ( yy_c_buf_p > yy_n_chars + 1 ) then",
+"        raise NULL_IN_INPUT;",
+"    end if;",
+"",
+"    -- try to read more data",
+"",
+"    -- first move last chars to start of buffer",
+"    number_to_move := yy_c_buf_p - yytext_ptr;",
+"",
+"    for i in 0..number_to_move - 1 loop",
+"        yy_ch_buf.data (dest) := yy_ch_buf.data (source);",
+"    dest := dest + 1;",
+"    source := source + 1;",
+"    end loop;",
+"        ",
+"    if ( yy_eof_has_been_seen ) then",
+"    -- don't do the read, it's not guaranteed to return an EOF,",
+"    -- just force an EOF",
+"",
+"    yy_n_chars := 0;",
+"    else",
+"    num_to_read := YY_BUF_SIZE - number_to_move - 1;",
+"",
+"    if ( num_to_read > YY_READ_BUF_SIZE ) then",
+"        num_to_read := YY_READ_BUF_SIZE;",
+"        end if;",
+"",
+"    -- read in more data",
+"    YY_INPUT( yy_ch_buf.data (number_to_move..yy_ch_buf.data'last), yy_n_chars, num_to_read );",
+"    end if;",
+"    if ( yy_n_chars = 0 ) then",
+"    if ( number_to_move = 1 ) then",
+"        ret_val := EOB_ACT_END_OF_FILE;",
+"    else",
+"        ret_val := EOB_ACT_LAST_MATCH;",
+"        end if;",
+"",
+"    yy_eof_has_been_seen := true;",
+"    else",
+"    ret_val := EOB_ACT_RESTART_SCAN;",
+"    end if;",
+"    ",
+"    yy_n_chars := yy_n_chars + number_to_move;",
+"    yy_ch_buf.data (yy_n_chars) := YY_END_OF_BUFFER_CHAR;",
+"    yy_ch_buf.data (yy_n_chars + 1) := YY_END_OF_BUFFER_CHAR;",
+"",
+"    -- yytext begins at the second character in",
+"    -- yy_ch_buf; the first character is the one which",
+"    -- preceded it before reading in the latest buffer;",
+"    -- it needs to be kept around in case it's a",
+"    -- newline, so yy_get_previous_state() will have",
+"    -- with '^' rules active",
+"",
+"    yytext_ptr := 1;",
+"",
+"    return ret_val;",
+"end yy_get_next_buffer;",
+"",
+"   procedure YYUnput (C : Wide_Wide_Character; YY_BP: in out Integer) is",
+"      number_to_move : Integer;",
+"      dest : integer;",
+"      source : integer;",
+"      tmp_yy_cp : integer;",
+"",
+"   begin",
+"      tmp_yy_cp := yy_c_buf_p;",
+"",
+"      if ( tmp_yy_cp < 2 ) then",
+"         -- need to shift things up to make room",
+"         number_to_move := yy_n_chars + 2; -- +2 for EOB chars",
+"         dest := YY_BUF_SIZE + 2;",
+"         source := number_to_move;",
+"",
+"         while ( source > 0 ) loop",
+"            dest := dest - 1;",
+"            source := source - 1;",
+"            yy_ch_buf.data (dest) := yy_ch_buf.data (source);",
+"         end loop;",
+"",
+"         tmp_yy_cp := tmp_yy_cp + dest - source;",
+"         yy_bp := yy_bp + dest - source;",
+"         yy_n_chars := YY_BUF_SIZE;",
+"",
+"         if ( tmp_yy_cp < 2 ) then",
+"            raise PUSHBACK_OVERFLOW;",
+"         end if;",
+"      end if;",
+"",
+"      if tmp_yy_cp > yy_bp",
+"        and then yy_ch_buf.data (tmp_yy_cp-1) = Ada.Characters.Wide_Wide_Latin_1.LF",
+"      then",
+"         yy_ch_buf.data (tmp_yy_cp-2) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"      end if;",
+"",
+"      tmp_yy_cp := tmp_yy_cp - 1;",
+"      yy_ch_buf.data (tmp_yy_cp) := c;",
+"",
+"      --  Note:  this code is the text of YY_DO_BEFORE_ACTION, only",
+"      --         here we get different yy_cp and yy_bp's",
+"      yytext_ptr := yy_bp;",
+"      yy_c_buf_p := tmp_yy_cp;",
+"   end yyunput;",
+"",
+"   procedure Unput (C : Wide_Wide_Character) is",
+"   begin",
+"      YYUnput (C, yy_bp);",
+"   end Unput;",
+"",
+"   function Input return Wide_Wide_Character is",
+"      C     : Wide_Wide_Character;",
+"      YY_CP : Integer := YY_C_Buf_P;",
+"",
+"   begin",
+"      if YY_CH_Buf.Data (YY_C_Buf_P) = YY_END_OF_BUFFER_CHAR then",
+"         --  need more input",
+"",
+"         yytext_ptr := yy_c_buf_p;",
+"         yy_c_buf_p := yy_c_buf_p + 1;",
+"",
+"         case yy_get_next_buffer is",
+"         -- this code, unfortunately, is somewhat redundant with",
+"         -- that above",
+"",
+"            when EOB_ACT_END_OF_FILE =>",
+"               if yywrap then",
+"                  yy_c_buf_p := yytext_ptr;",
+"",
+"                  return Ada.Characters.Wide_Wide_Latin_1.NUL;",
+"               end if;",
+"",
+"               yy_ch_buf.data (0) := Ada.Characters.Wide_Wide_Latin_1.LF;",
+"               yy_n_chars := 1;",
+"               yy_ch_buf.data (yy_n_chars) := YY_END_OF_BUFFER_CHAR;",
+"               yy_ch_buf.data (yy_n_chars + 1) := YY_END_OF_BUFFER_CHAR;",
+"               yy_eof_has_been_seen := false;",
+"               yy_c_buf_p := 1;",
+"               yytext_ptr := yy_c_buf_p;",
+"",
+"               return Input;",
+"",
+"            when EOB_ACT_RESTART_SCAN =>",
+"               yy_c_buf_p := yytext_ptr;",
+"",
+"            when EOB_ACT_LAST_MATCH =>",
+"               raise UNEXPECTED_LAST_MATCH;",
+"",
+"            when others => null;",
+"         end case;",
+"      end if;",
+"",
+"      c := yy_ch_buf.data (yy_c_buf_p);",
+"      yy_c_buf_p := yy_c_buf_p + 1;",
+"",
+"      return C;",
+"   end Input;",
+"",
+"   procedure Output (C : Wide_Wide_Character) is",
+"   begin",
+"      if Is_Open (User_Output_File) then",
+"         Put (User_Output_File, C);",
+"",
+"       else",
+"         Put (C);",
+"       end if;",
+"   end Output;",
+"",
+"   --  Default yywrap function - always treat EOF as an EOF",
+"",
+"   function YYWrap return Boolean is",
+"   begin",
+"      return True;",
+"   end YYWrap;",
+"",
+"   procedure Open_Input (FName : String) is",
+"   begin",
+"      YY_Init := True;",
+"      Open (User_Input_File, In_File, FName, ""wcem=8"");",
+"   end Open_Input;",
+"",
+"   procedure Create_Output (FName : String := """") is",
+"   begin",
+"      if fname /= """" then",
+"         Create (User_Output_File, Out_File, FName);",
+"      end if;",
+"   end Create_Output;",
+"",
+"   procedure Close_Input is",
+"   begin",
+"      if Is_Open (User_Input_File) then",
+"         Close (User_Input_File);",
+"      end if;",
+"   end Close_Input;",
+"",
+"   procedure Close_Output is",
+"   begin",
+"      if Is_Open (User_Output_File) then",
+"         Close (User_Output_File);",
+"      end if;",
+"   end Close_Output;",
+"",
+"-- UMASS CODES :",
+"procedure Yy_Get_Token_Line ( Yy_Line_String : out String;",
+"                              Yy_Line_Length : out Natural ) is",
+"begin",
+"  -- Currently processing line is either in saved token line1 or",
+"  -- in saved token line2.",
+"  if Yy_Line_Number = Line_Number_Of_Saved_Tok_Line1 then",
+"    Yy_Line_Length := Saved_Tok_Line1.all'length;",
+"    Yy_Line_String ( Yy_Line_String'First .. ( Yy_Line_String'First + Saved_Tok_Line1.all'length - 1 ))",
+"      := Saved_Tok_Line1 ( 1 .. Saved_Tok_Line1.all'length );",
+"  else",
+"    Yy_Line_Length := Saved_Tok_Line2.all'length;",
+"    Yy_Line_String ( Yy_Line_String'First .. ( Yy_Line_String'First + Saved_Tok_Line2.all'length - 1 ))",
+"      := Saved_Tok_Line2 ( 1 .. Saved_Tok_Line2.all'length );",
+"  end if;",
+"end Yy_Get_Token_Line;",
+"",
+"function Yy_Line_Number return Natural is",
+"begin",
+"   return Tok_Begin_Line;",
+"end Yy_Line_Number;",
+"",
+"function Yy_Begin_Column return Natural is",
+"begin",
+"   return Tok_Begin_Col;",
+"end Yy_Begin_Column;",
+"",
+"function Yy_End_Column return Natural is",
+"begin",
+"   return Tok_End_Col;",
+"end Yy_End_Column;",
+"",
+"-- END OF UMASS CODES.",
+""
--  IO TEMPLATE END
);

   IO_Current_Line : Integer := 1;

   ------------------
   -- Template_Out --
   ------------------

   procedure Template_Out
    (Out_File         : File_Type;
     Current_Template : File_Array;
     Line_Number      : in out Integer)
   is
-- UMASS CODES :
      Umass_Codes : Boolean := False;
      --  Indicates whether or not current line of the template
      --  is the Umass codes.
-- END OF UMASS CODES.
      Buf         : Unbounded_Wide_Wide_String;

   begin
      while not (Line_Number > Current_Template'Last) loop
         Buf := Current_Template (Line_Number);
         Line_Number := Line_Number + 1;

         if Length (Buf) >= 2 and then Slice (Buf, 1, 2) = "%%" then
            exit;
         else
-- UMASS CODES :
--   In the template, the codes between "-- UMASS CODES : " and
--   "-- END OF UMASS CODES." are specific to be used by Ayacc-extension.
--   Ayacc-extension has more power in error recovery. So we
--   generate those codes only when Ayacc_Extension_Flag is True.
            if Buf = "-- UMASS CODES :" then
               Umass_Codes := True;
            end if;

            if not Umass_Codes or else Ayacc_Extension_Flag then
               Put_Line (Out_File, Buf);
            end if;

            if Buf = "-- END OF UMASS CODES." then
               Umass_Codes := False;
            end if;
-- END OF UMASS CODES.

-- UCI CODES commented out :
--   The following line is commented out because it is done in Umass codes.
--      FILE_STRING.PUT_LINE(OUTFILE,BUF);
         end if;
      end loop;
   end Template_Out;

   -----------------------
   -- Generate_DFA_File --
   -----------------------

   procedure Generate_DFA_File is
      DFA_Out_Spec_File, DFA_Out_Body_File : File_Type;

   begin
      External_File_Manager.Get_DFA_Spec_File (DFA_Out_Spec_File);
      External_File_Manager.Get_DFA_Body_File (DFA_Out_Body_File);
      Put_Line (DFA_Out_Spec_File, "package " & Misc.Basename & ".DFA is");

      if DDebug then
         -- make a scanner that output acceptance information

         Put_Line (DFA_Out_Spec_File, "Aflex_Debug : Boolean := True;");

      else
         Put_Line (DFA_Out_Spec_File, "Aflex_Debug : Boolean := False;");
      end if;

      Template_Out (DFA_Out_Spec_File, DFA_Template, DFA_Current_Line);
      Put_Line (DFA_Out_Spec_File, "end " & Misc.Basename & ".DFA;");

      Put_Line (DFA_Out_Body_File, "package body " & Misc.Basename & ".DFA is");
      Template_Out (DFA_Out_Body_File, DFA_Template, DFA_Current_Line);
      Put_Line (DFA_Out_Body_File, "end " & Misc.Basename & ".DFA;");
   end Generate_DFA_File;

   ----------------------
   -- Generate_IO_File --
   ----------------------

   procedure Generate_IO_File is
      IO_Out_Spec_File, IO_Out_Body_File : File_Type;

   begin
      External_File_Manager.Get_IO_Spec_File (IO_Out_Spec_File);
      External_File_Manager.Get_IO_Body_File (IO_Out_Body_File);

      Put (IO_Out_Spec_File, "with " & Misc.Basename & ".DFA;");
      Put_Line (IO_Out_Spec_File, " use " & Misc.Basename & ".DFA;");
      Template_Out (IO_Out_Spec_File, IO_Template, IO_Current_Line);
      Put_Line (IO_Out_Spec_File, "package " & Misc.Basename & ".IO is");
      Template_Out (IO_Out_Spec_File, IO_Template, IO_Current_Line);
      Put_Line (IO_Out_Spec_File, "end " & Misc.Basename & ".IO;");

      Put_Line (IO_Out_Body_File, "package body " & Misc.Basename & ".IO is");
      Template_Out (IO_Out_Body_File, IO_Template, IO_Current_Line);

      -- If we're generating a scanner for interactive mode we need to generate
      -- a YY_INPUT that stops at the end of each line

      if Interactive then
         Put_Line
          (IO_Out_Body_File,
           "            i := i + 1; -- update counter, miss end of loop");
         Put_Line
          (IO_Out_Body_File,
           "            exit; -- in interactive mode return at end of line.");
      end if;

      Template_Out (IO_Out_Body_File, IO_Template, IO_Current_Line);
      Put_Line (IO_Out_Body_File, "end " & Misc.Basename & ".IO;");
   end Generate_IO_File;

end Template_Manager;