#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##
##  SPDX-License-Identifier: GPL-2.0-or-later
##
##  Copyright of GAP belongs to its developers, whose names are too numerous
##  to list here. Please refer to the COPYRIGHT file for details.
##
##  This file initializes GAP.
##


#############################################################################
##
#1 Temporary error handling until we are able to read error.g
##
##

#############################################################################
##
#F  OnBreak( )  . . . . . . . . . function to call at entry to the break loop
##
##
OnBreak := function() Print("An error has occurred before the traceback ",
        "functions are defined\n"); end;

#############################################################################
##
#F  OnBreakMessage( ) . . . . . . function to call at entry to the break loop
##
##  called after execution of `OnBreak' when an error condition is caused  by
##  an execution of `Error', to print what a user can do in order to exit the
##  break loop.
##
OnBreakMessage := function()
  Print("you can 'quit;' to quit to outer loop, or\n",
        "you can 'return;' to continue\n");
end;

#############################################################################
##
#F  OnQuit( ) . . . . . . . . . . function to call on quitting the break loop
##
##  called when a user elects to `quit;' a break loop entered  via  execution
##  of `Error'. Here we define it to do nothing, in  case,  we  encounter  an
##  `Error' when GAP is starting up (i.e. reading this file). `OnQuit'  is
##  later  redefined  to  do  a  variant  of  `ResetOptionsStack'  to  ensure
##  `OptionsStack' is empty after a user quits an `Error'-induced break loop.
##  Currently, `OnQuit( )' is not advertised, since  exception  handling  may
##  make it obsolete.
##
OnQuit := function() end;


Error := function( arg )
    local x;
    Print("Error before error-handling is initialized: ");
    for x in arg do
      Print(x);
    od;
    Print("\nwhile reading ", INPUT_FILENAME(), ":", INPUT_LINENUMBER(), "\n");
    if SHOULD_QUIT_ON_BREAK() then
        ForceQuitGap(1);
    fi;
    JUMP_TO_CATCH("early error");
end;

ErrorNoReturn := Error;

ErrorInner := function(options, message)
    Print("Error before error-handling is initialized: ");
    Print(message);
    Print("\nwhile reading ", INPUT_FILENAME(), ":", INPUT_LINENUMBER(), "\n");
    if SHOULD_QUIT_ON_BREAK() then
        ForceQuitGap(1);
    fi;
    JUMP_TO_CATCH("early error");
end;


#############################################################################
##
#F  Ignore( <arg> ) . . . . . . . . . . . . ignore but evaluate the arguments
##
#T  1996/08/07 M.Schönert 'Ignore' should be in the kernel
#T  1996/09/08 S.Linton    Do we need it at all?
##
Ignore := function ( arg )  end;


#############################################################################
##
##  Define some global variables
##
SetFilterObj := "2b defined";
infinity := "2b defined";


#############################################################################
##
#F  ReplacedString( <string>, <old>, <new> )
##
##  This cannot be inside "kernel.g" because it is needed to read "kernel.g".
##
ReplacedString := function ( str, old, new, arg... )
    local lss, all, p, s, pp;
    if old = new then
        return str;
    fi;
    lss := LEN_LIST( old );
    if lss = 0  then
        Error("<old> must not be empty");
    fi;
    if LEN_LIST( arg ) > 0  then
        all := arg[1] = "all";
    else
        all := true;
    fi;
    p := POSITION_SUBSTRING( str, old, 0 );
    if p = fail  then
        return str;
    fi;
    s := str{[  ]};
    pp := 0;
    while p <> fail  do
        APPEND_LIST_INTR( s, str{[ pp+1 .. p - 1 ]} );
        APPEND_LIST_INTR( s, new );
        pp := p + lss - 1;
        if all  then
            p := POSITION_SUBSTRING( str, old, pp );
        else
            p := fail;
        fi;
        if p = fail  then
            APPEND_LIST_INTR( s, str{[pp+1..LEN_LIST(str)]} );
        fi;
    od;
    return s;
end;


#############################################################################
##
#V  CHECK_INSTALL_METHOD  . . . . . .  check requirements in `INSTALL_METHOD'
##
CHECK_INSTALL_METHOD := true;


#############################################################################
##
#F  READ_GAP_ROOT( <name> ) . . . . . . . . .  read file from GAP's root area
#F  ReadGapRoot( <name> ) . . . . . . . . . .  read file from GAP's root area
##
##  <Ref Func="READ_GAP_ROOT"/> runs through &GAP;'s root directories
##  (see <Ref Sect="GAP Root Directories"/>),
##  reads the first readable file with name <A>name</A> relative to the root
##  directory, and then returns <K>true</K> if a file was read or
##  <K>false</K> if no readable file <A>name</A> was found in any root
##  directory.
##
##  <Ref Func="ReadGapRoot"/> calls <Ref Func="READ_GAP_ROOT"/> and signals
##  an error if <K>false</K> was returned; it does not return anything.
##
##  <Ref Func="READ_GAP_ROOT"/> and <Ref Func="ReadGapRoot"/> are used only
##  for reading files from the &GAP; library.
##  Note that the paths of files from &GAP; packages are determined by the
##  path of the <F>PackageInfo.g</F> file of the package in question.
##
ReadGapRoot := function( name )
    if not READ_GAP_ROOT(name)  then
        Error( "file \"", name, "\" must exist and be readable" );
    fi;
end;


#############################################################################
##
##  We will need this stuff to be able to bind global variables. Thus it
##  must be done first.
##
ReadGapRoot( "lib/kernel.g" );
ReadGapRoot( "lib/global.g" );


#############################################################################
##
##  Read architecture dependent data and other globals, such as version
##  information.
##
ReadGapRoot( "lib/system.g" );

if IsHPCGAP then
  FILTER_REGION := NEW_REGION("filter region", -1);
else
  BIND_GLOBAL("FILTER_REGION", "filter region");
fi;

#############################################################################
##
#V  ThreadVar  . . . . . . . . . . . . . . . . . . . . thread-local variables
if IsHPCGAP then
  BIND_GLOBAL("ThreadVar", ThreadLocalRecord());
  BIND_GLOBAL("BindThreadLocal", function(name, default)
    MakeThreadLocal(name);
    SetTLDefault(ThreadVar, name, default);
  end);
  BIND_GLOBAL("BindThreadLocalConstructor", function(name, default)
    MakeThreadLocal(name);
    SetTLConstructor(ThreadVar, name, default);
  end);
else
  BIND_GLOBAL("ThreadVar", rec());
  BIND_GLOBAL("BindThreadLocal", ASS_GVAR);
  BIND_GLOBAL("BindThreadLocalConstructor", function(name, fun)
    local ret;
    # Catch if the function returns a value
    ret := CALL_WITH_CATCH(fun,[]);
    if LEN_LIST(ret) > 1 then
      ASS_GVAR(name, ret[2]);
    fi;
  end);
fi;


#############################################################################
##
##  - Set or disable break loop according to the `-T' option.
##  - Set whether traceback may be suppressed (e.g. by `-T') according to the
##    `--alwaystrace' option.
##
CallAndInstallPostRestore( function()
    if IsHPCGAP then
      # In HPC-GAP we want to decide how to handle errors on a per thread
      # basis. E.g. the break loop can be disabled in a worker thread that
      # runs tasks.
      BindThreadLocal( "BreakOnError", not GAPInfo.CommandLineOptions.T );
      BindThreadLocal(
        "AlwaysPrintTracebackOnError",
        GAPInfo.CommandLineOptions.alwaystrace
      );
      BindThreadLocal( "SilentNonInteractiveErrors", false );
      # We store the error messages on a per thread basis to be able to
      # e.g. access them independently from the main thread.
      BindThreadLocal( "LastErrorMessage", "" );
    else
      ASS_GVAR( "BreakOnError", not GAPInfo.CommandLineOptions.T );
      ASS_GVAR( "AlwaysPrintTracebackOnError", GAPInfo.CommandLineOptions.alwaystrace );
      ASS_GVAR( "SilentNonInteractiveErrors", false );
    fi;
end);

ReadOrComplete := function(name)
    if GAPInfo.CommandLineOptions.D then
        Print( "#I  reading ", name, "\n" );
    fi;
    if not READ_GAP_ROOT( name ) then
        Error( "cannot read file ", name );
    fi;
end;


#############################################################################
##
#F  ReadAndCheckFunc( <path> )
##
##  `ReadAndCheckFunc' creates a function that take an argument <name>, and
##  then reads in a file named <name> from <path>.
##  This can be used for partial reading of the library.
##
BIND_GLOBAL("ReadAndCheckFunc",function( path )

    path := IMMUTABLE_COPY_OBJ(path);

    return function( name )
        local  libname, error;

        # create a filename from <path> and <name>
        libname := SHALLOW_COPY_OBJ(path);
        APPEND_LIST_INTR( libname, "/" );
        APPEND_LIST_INTR( libname, name );

        error := not READ_GAP_ROOT(libname);

        if error then
          Error( "the library file '", libname, "' must exist and ",
                 "be readable");
        fi;

    end;
end);

#############################################################################
##
#F  ReadLib( <name> ) . . . . . . . . . . . . . . . . . . . . . library files
#F  ReadGrp( <name> ) . . . . . . . . . . . . . . . . . . group library files
##
BIND_GLOBAL("ReadLib",ReadAndCheckFunc("lib"));
BIND_GLOBAL("ReadGrp",ReadAndCheckFunc("grp"));


#############################################################################
##
##  Define functions which may not be available to avoid syntax errors
##
NONAVAILABLE_FUNC:=function(arg)
local s;
  if LENGTH(arg)=0 then
    return function(arg)
            Error("this function is not available");
          end;
  else
    s:=arg[1];
    return function(arg)
            Error("the ",s," is required but not installed");
          end;
  fi;
end;

# these functions will be overwritten if loaded
IdGroup:=NONAVAILABLE_FUNC("Small Groups identification");
SmallGroup:=NONAVAILABLE_FUNC("Small Groups library");
PrimitiveGroup:=NONAVAILABLE_FUNC("Primitive Groups library");

#############################################################################
##
##  Initialize functions for the source of small group lib and id library
##
ID_AVAILABLE := x -> fail;

#############################################################################
##
#X  read in the files
##


# inner functions, needed in the kernel
ReadGapRoot( "lib/read1.g" );
ExportToKernelFinished();
if IsHPCGAP then
  ENABLE_AUTO_RETYPING();
fi;


#############################################################################
##
##  The command line option '-L' is supported only if GASMAN is used.
##
if "-L" in GAPInfo.SystemCommandLine and GAPInfo.KernelInfo.GC <> "GASMAN" then
  Error( "workspaces (-L option) are supported only if GASMAN is used" );
fi;


# try to find terminal encoding
CallAndInstallPostRestore( function()
  local env, pos, enc, a, PositionSublist;
  PositionSublist := function (str, sub)
    local i;

    for i in [1..Length(str)-Length(sub)+1] do
       if str{[i..i+Length(sub)-1]}=sub then
         return i;
       fi;
    od;
    return fail;
  end;

  # we leave the GAPInfo.TermEncodingOverwrite for gaprc
  # for a moment, but don't document it - doesn't work with
  # loaded workspaces
  if not IsBound(GAPInfo.TermEncodingOverwrite) then
    if IsList(GAPInfo.SystemEnvironment) then
      # for compatibility with GAP 4.4.
      env := rec();
      for a in GAPInfo.SystemEnvironment do
        pos := Position(a, '=');
        env.(a{[1..pos-1]}) := a{[pos+1..Length(a)]};
      od;
    else
      env := GAPInfo.SystemEnvironment;
    fi;
    enc := fail;
    if IsBound(env.LC_ALL) then
      enc := env.LC_ALL;
    fi;
    if enc = fail and IsBound(env.LC_CTYPE) then
      enc := env.LC_CTYPE;
    fi;
    if enc = fail and IsBound(env.LANG) then
      enc := env.LANG;
    fi;
    if enc <> fail then
      enc:=STRING_LOWER(enc);
      if (PositionSublist(enc, "utf-8") <> fail  or
          PositionSublist(enc, "utf8") <> fail) then
        GAPInfo.TermEncoding := "UTF-8";
      fi;
    fi;
    if not IsBound(GAPInfo.TermEncoding) then
      # default is latin1
      GAPInfo.TermEncoding := "ISO-8859-1";
    fi;
  else
    GAPInfo.TermEncoding := GAPInfo.TermEncodingOverwrite;
  fi;
  MakeImmutable( GAPInfo.TermEncoding );
end );

BindGlobal("_PrintInfo",
function( prefix, values, suffix )
  local linelen, indent, PL, comma, N;

  linelen:= SizeScreen()[1] - 2;
  indent := "             ";

  Print( prefix );
  PL:= Length(prefix)+1;
  comma:= "";
  for N in values do
    Print( comma );
    PL:= PL + Length( comma );
    if PL + Length( N ) > linelen then
      Print( "\n", indent);
      PL:= Length(indent)+1;
    fi;
    Print( N, "\c" );
    PL:= PL + Length( N );
    comma:= ", ";
  od;
  if PL + Length( suffix ) + 1 > linelen then
    Print( "\n", indent);
  fi;
  Print( suffix );
end);

BindGlobal( "ShowKernelInformation", function()
  local sysdate, btop, vert, bbot, config, str, gap;

  if GAPInfo.Date <> "today" then
    sysdate := " of ";
    Append(sysdate, GAPInfo.Date);
  elif GAPInfo.BuildDateTime = "reproducible" then
    sysdate := "";
  else
    sysdate := " built on ";
    Append(sysdate, GAPInfo.BuildDateTime);
  fi;

  if GAPInfo.TermEncoding = "UTF-8" then
    btop := "┌───────┐\c"; vert := "│"; bbot := "└───────┘\c";
  else
    btop := "*********"; vert := "*"; bbot := btop;
  fi;
  if IsHPCGAP then
    gap := "HPC-GAP";
  else
    gap := "GAP";
  fi;
  Print( " ",btop,"   ",gap," ", GAPInfo.BuildVersion,
         sysdate, "\n",
         " ",vert,"  GAP  ",vert,"   https://www.gap-system.org\n",
         " ",bbot,"   Architecture: ", GAPInfo.Architecture, "\n" );
  if IsHPCGAP then
    Print( "             Maximum concurrent threads: ",
       GAPInfo.KernelInfo.NUM_CPUS, "\n");
  fi;
  # For each library or configuration setting, print some info.
  config:= [];
  # always mention GMP
  if true then
    if IsBound( GAPInfo.KernelInfo.GMP_VERSION ) then
      str := "gmp ";
      Append(str, GAPInfo.KernelInfo.GMP_VERSION);
    else
      str := "gmp";
    fi;
    Add( config, str );
  fi;
  if IsBound( GAPInfo.KernelInfo.GC ) then
    Add( config, GAPInfo.KernelInfo.GC );
  fi;
  if IsBound( GAPInfo.KernelInfo.JULIA_VERSION ) then
    str := "Julia ";
    Append(str, GAPInfo.KernelInfo.JULIA_VERSION);
    Add( config, str );
  fi;
  if IsBound( GAPInfo.UseReadline ) then
    Add( config, "readline" );
  fi;
  if GAPInfo.KernelInfo.KernelDebug then
    Add( config, "KernelDebug" );
  fi;
  if GAPInfo.KernelInfo.MemCheck then
    Add(config, "MemCheck");
  fi;
  if config <> [] then
    _PrintInfo( " Configuration:  ", config, "\n" );
  fi;
  if GAPInfo.CommandLineOptions.L <> "" then
    Print( " Loaded workspace: ", GAPInfo.CommandLineOptions.L, "\n" );
  fi;
  if IsHPCGAP then
    Print("\n",
          "#W <<< This is an alpha release.      >>>\n",
          "#W <<< Do not use for important work. >>>\n",
      "\n");
  fi;
end );

# delay printing the banner, if -L option was passed (LB)

CallAndInstallPostRestore( function()
     if not ( GAPInfo.CommandLineOptions.q or
              GAPInfo.CommandLineOptions.b or GAPInfo.CommandLineOptions.L<>"" ) then
       ShowKernelInformation();
     fi;
     end );

#############################################################################
##
##  Name of option to avoid precomputed data libraries -- made a variable so
##  it can still be changed easily
##
BindGlobal("NO_PRECOMPUTED_DATA_OPTION","NoPrecomputedData");


if not ( GAPInfo.CommandLineOptions.q or GAPInfo.CommandLineOptions.b ) then
    Print (" Loading the library \c");
fi;

ReadOrComplete( "lib/read2.g" );
ReadOrComplete( "lib/read3.g" );

#  Force population of GAPInfo.DirectoryCurrent
#  Do it now so that Directory works, but it is available
#  to package code.
#
CallAndInstallPostRestore(DirectoryCurrent);

#############################################################################
##
#F  NamesGVars()  . . . . . . . . . . . list of names of all global variables
##
##  This function returns an immutable (see~"Mutability and Copyability")
##  sorted (see~"Sorted Lists and Sets") list of all the global
##  variable names known to the system.  This includes names of variables
##  which were bound but have now been unbound and some other names which
##  have never been bound but have become known to the system by various
##  routes.
##
##  We need this BEFORE we read profile.g
##
BindGlobal( "NamesGVars", function()
    local names;
    names:= Set( IDENTS_GVAR() );
    MakeImmutable( names );
    return names;
end );


# help system, profiling
ReadOrComplete( "lib/read4.g" );

# Here are a few general user preferences which may be useful for
# various purposes. They are self-explaining.
DeclareUserPreference( rec(
  name:= "UseColorsInTerminal",
  description:= [
    "Almost all current terminal emulations support color display, \
setting this to <K>true</K> implies a default display of most manuals with \
color markup. It may influence the display of other things in the future."
    ],
  default:= true,
  values:= [ true, false ],
  multi:= false,
  ) );
DeclareUserPreference( rec(
  name:= "ViewLength",
  description:= [
    "A bound for the number of lines printed when <C>View</C>ing some large objects."
    ],
  default:= 3,
  check:= val -> IsInt( val ) and 0 <= val,
  ) );
DeclareUserPreference( rec(
  name:= "ReproducibleBehaviour",
  description:= [
    "This preference disables code in &GAP; which changes behaviour based on time \
spent, and therefore can produce different results depending on how much time is \
taken by other programs running on the same computer. This option may lead to \
slower or lower-quality results.\
\n\
Note that many algorithms in &GAP; use the global random number generator, which is \
NOT affected by this option. This only tries to ensure the same version of &GAP;, \
with the same package versions loaded, on the same machine, running the same code, \
in a fresh &GAP; session, will produce the same results."
    ],
  default:= false,
  values:= [ true, false ],
  multi:= false,
  ) );

# This provides a substitute for the function Runtime(), for use
# with the user option ReproducibleBehaviour. Instead of measuring
# time, it simply increments a global variable each time it is called.
FAKE_RUNTIME_COUNT := 0;
BindGlobal("FAKE_RUNTIME", function()
    FAKE_RUNTIME_COUNT := FAKE_RUNTIME_COUNT + 1;
    return FAKE_RUNTIME_COUNT;
end);

# get the timing function which should be used, which is either
# FAKE_RUNTIME, or Runtime, depending on the current value of
# ReproducibleBehaviour.

BindGlobal("GET_TIMER_FROM_ReproducibleBehaviour",
function()
    if UserPreference("ReproducibleBehaviour") then
        return FAKE_RUNTIME;
    else
        return Runtime;
    fi;
end);


############################################################################
##
#X  Name Synonyms for different spellings
##
ReadLib("transatl.g");


CallAndInstallPostRestore( function()
    READ_GAP_ROOT( "gap.ini" );
end );


#############################################################################
##
#X  files installing compatibility with deprecated, obsolescent or
##  obsolete GAP4 behaviour;
##  *not* to be read if `UserPreference( "ReadObsolete" )' has the value
##  `false'
##  (this value can be set in the `gap.ini' file)
##
# reading can be configured via a user preference
DeclareUserPreference( rec(
  name:= "ReadObsolete",
  description:= [
    "May be useful to say <K>false</K> here to check if you are using commands \
which may vanish in a future version of &GAP;"
    ],
  default:= true,
  values:= [ true, false ],
  multi:= false,
  ) );

ReadLib("obsolete.g"); # the helpers in there are always read
CallAndInstallPostRestore( function()
    if not GAPInfo.CommandLineOptions.O and UserPreference( "ReadObsolete" ) <> false and
       not IsBound( GAPInfo.Read_obsolete_gd ) then
      ReadLib( "obsolete.gd" );
      GAPInfo.Read_obsolete_gd:= true;
    fi;
end );


#############################################################################
##
##  Load the implementation part of the GAP library.
##
ReadGapRoot( "lib/read.g" );


#############################################################################
##
##  Autoload packages (suppressing banners).
##  (If GAP was started with a workspace then the user may have given
##  additional directories, so more suggested packages may become available.
##  So we have to call `AutoloadPackages' also then.
##  Note that we have to use `CallAndInstallPostRestore' not
##  `InstallAndCallPostRestore' because some packages may install their own
##  post-restore functions, and when a workspaces gets restored then these
##  functions must be called *before* loading new packages.)
##
##  Load additional packages, such that their names appear in the banner.
##
if not ( GAPInfo.CommandLineOptions.q or GAPInfo.CommandLineOptions.b ) then
    Print ("and packages ...\n");
fi;
CallAndInstallPostRestore( AutoloadPackages );


############################################################################
##
##  Propagate the user preferences.
##  (This function cannot be called earlier,
##  since the GAP library may not be loaded before.)
##
CallAndInstallPostRestore( function()
    local   xy;

    # screen size (options `-x' and `-y').
    xy := [];
    if GAPInfo.CommandLineOptions.x <> "" then
        xy[1] := SMALLINT_STR(GAPInfo.CommandLineOptions.x);
    fi;
    if GAPInfo.CommandLineOptions.y <> "" then
        xy[2] := SMALLINT_STR(GAPInfo.CommandLineOptions.y);
    fi;
    if xy <> [] then
        SizeScreen(xy);
    fi;

    # option `-g'
    if GAPInfo.KernelInfo.GC = "GASMAN" then
      if   GAPInfo.CommandLineOptions.g = 0 then
        SetGasmanMessageStatus( "none" );
      elif GAPInfo.CommandLineOptions.g = 1 then
        SetGasmanMessageStatus( "full" );
      else
        SetGasmanMessageStatus( "all" );
      fi;
    fi;

    # maximal number of lines that are reasonably printed
    # in `ViewObj' methods
    GAPInfo.ViewLength:= UserPreference( "ViewLength" );

    # user preference `UseColorPrompt'
    ColorPrompt( UserPreference( "UseColorPrompt" ) );
end );


#############################################################################
##
#X  files installing compatibility with deprecated, obsolescent or
##  obsolete GAP4 behaviour;
##  *not* to be read if `UserPreference( "ReadObsolete" )' has the value
##  `false'
##  (this value can be set in the `gap.ini' file)
##
CallAndInstallPostRestore( function()
    if not GAPInfo.CommandLineOptions.O and UserPreference( "ReadObsolete" ) <> false and
       not IsBound( GAPInfo.Read_obsolete_gi ) then
      ReadLib( "obsolete.gi" );
      GAPInfo.Read_obsolete_gi:= true;
    fi;
end );


#############################################################################
##
##  Install SaveCommandLineHistory as exit function and read history from
##  file, depending on user preference.
##
CallAndInstallPostRestore( function()
  if UserPreference("SaveAndRestoreHistory") = true then
    InstallAtExit(SaveCommandLineHistory);
    ReadCommandLineHistory();
  fi;
end );

#############################################################################
##
##  If the command line option `-r' is not given
##  and if no `gaprc' file has been read yet (if applicable then including
##  the times before the current workspace had been created)
##  then read the first `gaprc' file from the GAP root directories.
##
CallAndInstallPostRestore( function()
    if READ_GAP_ROOT( "gaprc" ) then
      GAPInfo.HasReadGAPRC:= true;
    elif not IsExistingFile(GAPInfo.UserGapRoot) then
      # For compatibility with GAP 4.4:
      # If no readable `gaprc' file exists in the GAP root directories and
      # the user root directory does not (yet) exist then
      # try to read `~/.gaprc' (on UNIX systems) or `gap.rc' (otherwise).
      if not ( GAPInfo.CommandLineOptions.r or GAPInfo.HasReadGAPRC ) then
        if ARCH_IS_UNIX() then
          GAPInfo.gaprc:= SHALLOW_COPY_OBJ( GAPInfo.UserHome );
          if IsString(GAPInfo.gaprc) then
            APPEND_LIST_INTR( GAPInfo.gaprc, "/.gaprc" );
          fi;
        else
          GAPInfo.gaprc:= "gap.rc";
        fi;
        if IsString(GAPInfo.gaprc) and READ( GAPInfo.gaprc ) then
          Info(InfoWarning, 1,
            "You are using an old ",GAPInfo.gaprc, " file. ");
          Info(InfoWarning, 1,
            "See '?Ref: The former .gaprc file' for hints to upgrade.");
          GAPInfo.HasReadGAPRC:= true;
        fi;
      fi;
    fi;
end );


#############################################################################
##
##  Display loaded packages
##

BindGlobal( "ShowPackageInformation", function()
  local packagenames;

  # For each loaded package, print name and version number.
  packagenames := SortedList( RecNames( GAPInfo.PackagesLoaded ) );
  if not IsEmpty(packagenames) then
    _PrintInfo( " Packages:   ",
               List( packagenames,
                     name -> Concatenation(
                                 GAPInfo.PackagesLoaded.( name )[3], " ",
                                 GAPInfo.PackagesLoaded.( name )[2] ) ),
               "\n" );
  fi;

  Print( " Try '??help' for help. See also '?copyright', '?cite' and '?authors'",
         "\n" );
end );
#T show also root paths?

CallAndInstallPostRestore( function()
     if not ( GAPInfo.CommandLineOptions.q or
              GAPInfo.CommandLineOptions.b ) then
       if GAPInfo.CommandLineOptions.L<>"" then
         ShowKernelInformation();
       fi;
       ShowPackageInformation();
     fi;
     end );

BindGlobal ("ShowSystemInformation", function ()
    ShowKernelInformation();
    ShowPackageInformation();
end );


#############################################################################
##
##  Finally, deal with the lists of global variables.
##  This must be done at the end of this file,
##  since the variables defined in packages are regarded as system variables.
#T But this way also the variables that get bound in `gaprc' are regarded
#T as system variables!
##


#############################################################################
##
#F  NamesSystemGVars()  . . . . . .  list of names of system global variables
##
##  This function returns an immutable sorted list of all the global
##  variable names created by the GAP library when GAP was started.
##
NAMES_SYSTEM_GVARS := Filtered( IDENTS_GVAR(), ISB_GVAR );
Add( NAMES_SYSTEM_GVARS, "NamesUserGVars" );
Add( NAMES_SYSTEM_GVARS, "NamesSystemGVars" );
Add( NAMES_SYSTEM_GVARS, "NAMES_SYSTEM_GVARS" );
Add( NAMES_SYSTEM_GVARS, "last" );
Add( NAMES_SYSTEM_GVARS, "last2" );
Add( NAMES_SYSTEM_GVARS, "last3" );
Add( NAMES_SYSTEM_GVARS, "time" );
NAMES_SYSTEM_GVARS := Set( NAMES_SYSTEM_GVARS );
MakeImmutable( NAMES_SYSTEM_GVARS );
MakeReadOnlyGlobal( "NAMES_SYSTEM_GVARS" );

BIND_GLOBAL( "NamesSystemGVars", function()
    return NAMES_SYSTEM_GVARS;
end);


#############################################################################
##
#F  NamesUserGVars()  . . . . . . . .  list of names of user global variables
##
##  This function returns an immutable sorted list of the global variable
##  names created since the library was read, to which a value is
##  currently bound.
##
BIND_GLOBAL( "NamesUserGVars", function()
    local names;
    names:= Filtered( Difference( NamesGVars(), NamesSystemGVars() ),
                      ISB_GVAR );
    MakeImmutable( names );
    return names;
end);

#############################################################################
##
##  Initialize the help books of the library
##
HELP_ADD_BOOK("Tutorial", "GAP 4 Tutorial", "doc/tut");
HELP_ADD_BOOK("Reference", "GAP 4 Reference Manual", "doc/ref");
if IsHPCGAP then
  HELP_ADD_BOOK("HPC-GAP", "HPC-GAP Reference Manual", "doc/hpc");
fi;
if ForAny( GAPInfo.RootPaths,
           rp -> IsDirectoryPath( Concatenation( rp, "/doc/dev" ) ) ) then
  HELP_ADD_BOOK("Development", "GAP 4 Development Manual", "doc/dev");
fi;


#############################################################################
##
##  Read init files, run a shell, and do exit-time processing.
##

ResumeMethodReordering();

BindGlobal( "ProcessInitFiles", function(initFiles)
    local i, f;
    for i in [1..Length(initFiles)] do
        f := initFiles[i];
        if IsRecord(f) then
            Read(InputTextString(f.command));
        elif EndsWith(f, ".tst") then
            Test(f);
        else
            Read(f);
        fi;
    od;
end );

InstallAndCallPostRestore( function()
    ProcessInitFiles(GAPInfo.InitFiles);
end );

if GAPInfo.CommandLineOptions.norepl then
  # do not start an interactive session
elif IsHPCGAP and THREAD_UI() then
  ReadLib("hpc/consoleui.g");
  MULTI_SESSION();
  PROGRAM_CLEAN_UP();
else
  SESSION();
  PROGRAM_CLEAN_UP();
fi;