import java.io.*;

class Common
{
   public static antlr.Parser input_parser;
   public static String input_file_name;

   public static ParserInfo info;
   public static String product_ns = "";

   /* rule mode */

   public static final int NEW_MODE = 1;
   public static final int MODIFY_MODE = 2;
   public static final int RETURN_MODE = 3;
   public static final int SELECT_MODE = 4;
   public static final int CHOOSE_MODE = 5;
   public static final int BINARY_MODE = 6;
   public static final int UNARY_MODE = 7;
   public static final int PRIMITIVE_MODE = 8;
   public static final int NONAME_MODE = 9;

   /* nonterminal kind */

   public static final int LABELED   =  1; // store into field
   public static final int INSERT    =  2; // insert into sequence
   public static final int ADD       =  3; // insert into 'items' sequence
   public static final int ASSIGN    =  4; // store into local variable
   public static final int CALL      =  5; // call rule with <modify> attribute
   public static final int RESULT    =  6; // set rule result
   public static final int ANONYMOUS =  7;

   public static final int SELECT    =  8;
   public static final int CHOOSE1   =  9;
   public static final int CHOOSE2   = 10;

   /* style options */

   public static final int SPACE = 1;
   public static final int NO_SPACE = 2;
   public static final int NEW_LINE = 3;
   public static final int EMPTY_LINE = 4;
   public static final int NO_EMPTY_LINE = 5;
   public static final int INDENT = 6;
   public static final int UNINDENT = 7;

   /* strings */

   public static boolean empty (String s)
   {
     return s == null || s.length() == 0;
   }

   public static String strip (String s) // used in tree.g
   {
     return s.substring (1, s.length()-1);
   }

   public static boolean isIdentifier (String s)
   {
      boolean b = true;
      int len = s.length ();

      for (int i = 0; b && i < len; i++)
      {
         char c = s.charAt (i);
         if (!( c >= 'a' && c <= 'z' ||
                c >= 'A' && c <= 'Z' ||
                c >= '0' && c <= '9' || c == '_' )) b = false;
      }

      return b;
   }

   /* line numbers */

   public static int getLineNumber ()
   {
      int result = 0;

      try
      {
         result = input_parser.LT(1).getLine ();
      }
      catch (antlr.TokenStreamException e)
      {
         // nothing
      }

      return result;
   }

   /* streams */

   public static StreamInfo commonHeaderPack;
   public static StreamInfo commonCodePack;
   public static StreamInfo publicHeaderPack;
   public static StreamInfo privateHeaderPack;

   public static StreamInfo lexerGrammarPack;
   public static StreamInfo parserGrammarPack;

   public static StreamInfo symbolHeaderPack;
   public static StreamInfo lexerHeaderPack;
   public static StreamInfo lexerCodePack;
   public static StreamInfo parserHeaderPack;
   public static StreamInfo parserCodePack;

   public static StreamInfo productHeaderPack;
   public static StreamInfo productCodePack;

   // auxiliary streams (not for direct file output)
   public static StreamInfo parserDeclPack;
   public static StreamInfo parserImplPack;

   private static StreamInfo open (String file_name)
   {
      final int BUF_SIZE = 4096;
      StreamInfo pack = new StreamInfo ();

      pack.fileName = file_name;

      pack.data = new ByteArrayOutputStream (BUF_SIZE);

      pack.memoryStream =
         new PrintStream (
            new BufferedOutputStream (pack.data, BUF_SIZE ));

      return pack;
   }

   private static void close (StreamInfo pack)
   {
      pack.memoryStream.close ();
   }

   public static void openStreams (String out_dir)
   {
      commonHeaderPack  = open (out_dir + info.common_header + ".hpp");
      commonCodePack    = open (out_dir + info.common_name + ".cpp");
      publicHeaderPack  = open (out_dir + info.public_header + ".hpp");
      privateHeaderPack = open (out_dir + info.private_header + ".hpp");

      lexerGrammarPack  = open (out_dir + info.lexer_name + ".gpp");
      parserGrammarPack = open (out_dir + info.parser_name + ".gpp");

      symbolHeaderPack  = open (out_dir + info.symbol_header + ".hpp");
      lexerHeaderPack   = open (out_dir + info.lexer_name + ".hpp");
      lexerCodePack     = open (out_dir + info.lexer_name + ".cpp");
      parserHeaderPack  = open (out_dir + info.parser_name + ".hpp");
      parserCodePack    = open (out_dir + info.parser_name + ".cpp");

      productHeaderPack = open (out_dir + info.product_name + ".hpp");
      productCodePack   = open (out_dir + info.product_name + ".cpp");

      parserDeclPack    = open ("");
      parserImplPack    = open ("");

      code = false; // code / grammar
   }

   private static void store (StreamInfo pack)
   {
      if (! empty (pack.fileName))

      try
      {
         int len = pack.data.size ();
         boolean equal = false;

         File file = new File (pack.fileName);
         if (file.exists ())
         {
            FileInputStream stream = new FileInputStream (pack.fileName);
            if (stream.available () == len)
            {
               byte [] buf1 = new byte [len];
               stream.read (buf1);

               byte [] buf2 = pack.data.toByteArray ();

               equal = true;
               for (int i=0; i<len && equal; i++)
                  if (buf1[i] != buf2[i])
                     equal = false;
            }
            stream.close ();
         }

         if (equal)
         {
            // FileOutputStream stream = new FileOutputStream (fileName + ".equ");
            // data.writeTo (stream);
            // stream.close ();
            printInfo (pack.fileName + " equal");
         }
         else

         {
            FileOutputStream stream = new FileOutputStream (pack.fileName);
            pack.data.writeTo (stream);
            stream.close ();
            printInfo (pack.fileName + " modified");
         }

      }
      catch (FileNotFoundException e)
      {
          err ("File not found: " + pack.fileName);
      }
      catch (IOException e)
      {
          err ("IO Exception: " + e);
      }
   }

   public static void closeStreams ()
   {
      close (commonHeaderPack);
      close (commonCodePack);
      close (publicHeaderPack);
      close (privateHeaderPack);

      close (lexerGrammarPack);
      close (parserGrammarPack);

      close (symbolHeaderPack);
      close (lexerHeaderPack);
      close (lexerCodePack);
      close (parserHeaderPack);
      close (parserCodePack);

      close (productHeaderPack);
      close (productCodePack);

      // close (parserDeclPack);
      // close (parserImplPack);

      /* store data */

      store (commonHeaderPack);

      store (commonCodePack);

      if (info.enable_public_header)
         store (publicHeaderPack);

      if (info.enable_private_header)
         store (privateHeaderPack);

      if (info.enable_lexer_output && info.antlr_mode)
         store (lexerGrammarPack);

      if (info.antlr_mode)
         store (parserGrammarPack);

      if (! info.antlr_mode)
      {
         if (info.enable_symbol_header)
            store (symbolHeaderPack);

         if (info.enable_lexer_output)
         {
            store (lexerHeaderPack);
            store (lexerCodePack);
         }

         store (parserHeaderPack);
         store (parserCodePack);
      }

      store (productHeaderPack);
      store (productCodePack);
   }

   /* info */

   public static void printErrInfo (String s)
   {
      System.err.println (s);
   }

   public static void printInfo (String s)
   {
      System.out.println (s);
   }

   public static void err (String s)
   {
      printErrInfo (s);
      throw new RuntimeException (s);
   }

   /* print */

   private static PrintStream printStream = System.out;
   private static boolean start_line = true;
   private static boolean finish_line = false;
   public  static int indent = 0;

   public static void switchTo (StreamInfo pack)
   {
      print_tail (); // print last end of line

      printStream = pack.memoryStream;
      indent = 0;
      start_line = true;
      finish_line = false;
   }

   public static void copyFrom (StreamInfo pack)
   {
      pack.memoryStream.close ();

      try
      {
         pack.data.writeTo (printStream);
      }
      catch (IOException e)
      {
          err ("Error copying stream");
      }
   }

   public static void copy (String dir, String fileName, String subst)
   {
      final char mark = '%';

      boolean replace = ! empty (subst);

      try
      {
         DataInputStream input =
            new DataInputStream (
               new BufferedInputStream (
                 new FileInputStream (dir + fileName) ));

         println ("");
         println ("/* begin of " + fileName + " */");
         println ("");

         while (input.available () > 0)
         {
            String s = input.readLine ();

            if (replace)
            {
               int inx = s.indexOf (mark);
               while (inx >= 0)
               {
                   s = s.substring (0, inx) + subst + s.substring (inx+1);
                   inx = s.indexOf (mark, inx + 1 + subst.length ());
               }
            }

            println (s);
         }

         println ("");
         println ("/* end of " + fileName + " */");
         println ("");

         input.close ();
      }
      catch (FileNotFoundException e)
      {
          err ("File not found: " + fileName);
      }
      catch (IOException e)
      {
          err ("Error reading file: " + fileName);
      }
   }

   public static void print_extension (String name)
   {
      if (info.extension_repository.contains (name))
      {
         DictItem2 item = (DictItem2) info.extension_repository.get (name);
         if (! start_line) println ("");
         println ("// extension " + name);

         String txt = item.value;
         int inx = 0;
         int len = txt.length ();

         final char cr  = '\r';
         final char lf  = '\n';
         final char tab = '\t';

         // skip first empty line
         while (inx < len && (txt.charAt (inx) == ' ' || txt.charAt (inx) == tab))
            inx ++;

         if (inx < len && txt.charAt (inx) == cr)
            inx ++;

         if (inx < len && txt.charAt (inx) == lf)
            inx ++;

         while (inx < len)
         {
            int start = inx;

            while (inx < len && txt.charAt (inx) != cr && txt.charAt (inx) != lf)
               inx ++;

            if (inx > start)
               print (txt.substring (start, inx));

            if (inx < len && (txt.charAt (inx) == cr || txt.charAt (inx) == lf))
            {
               println ("");
               if (txt.charAt (inx) == cr)
               {
                  inx ++;
                  if (inx < len && txt.charAt (inx) == lf) inx ++;
               }
               else
               {
                  inx ++;
               }
            }
         }

         if (! start_line) println ("");
         println ("// end of extension " + name);
         println ("");
      }
   }

   private static void print_tail ()
   {
     if (finish_line)
     {
        printStream.println ("");
        finish_line = false;
     }
   }

   private static void print_indentation ()
   {
     if (start_line)
     {
        for (int i = 1; i <= indent; i++)
           printStream.print ("   ");
        start_line = false;
     }
   }

   private static void print_undo_eol ()
   {
      finish_line = false; // continue with last line
      start_line = false; // no indentation
   }

   public static void print (String s)
   {
     print_tail ();
     print_indentation ();
     printStream.print (s);
   }

   public static void println (String s)
   {
     print (s);
     finish_line = true;
     start_line = true;
   }

   public static void print_comment (String s)
   {
     println ("/* %% " + s + " */");

     println ("");
   }

   /* print code / grammar */

   static boolean code;

   public static void printCode ()
   {
      if (! code)
      {
         // print ("{ ");
         print ("{ ");
         indent ++;
         code = true;
      }
   }

   public static void printGrammar ()
   {
      if (code)
      {
         print_undo_eol (); // continue with last line

         // println (" }");

         indent --;
         println (" }");

         code = false;
      }
   }

}