Changeset 565 for CMT/HEAD


Ignore:
Timestamp:
Apr 13, 2011, 1:28:08 PM (13 years ago)
Author:
rybkin
Message:

See C.L. 448

Location:
CMT/HEAD
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • CMT/HEAD/ChangeLog

    r564 r565  
     12011-04-12    <rybkin@lal.in2p3.fr> 448
     2
     3        * source/cmt_awk.cxx: In class FAwk, in functions run, return failed on
     4        error reading file
     5        * source/cmt_system.cxx: In class CmtSystem, introduce and implement
     6        functions mangle
     7        * source/cmt_system.h: idem
     8        * source/cmt_install_area.cxx: In class CmtInstallAreaMgr, in function
     9        build_current_installarea, make use of Use::current (instead of pwd)
     10        * source/cmt_commands.cxx: In class ArgParser, functions
     11        option_with(out)_cmt, add -with(out)_cmt to cmtflags
     12        * source/cmt_project.cxx: In class Project, in function find_in_cmt_paths,
     13        do not invoke pwd
     14        * source/cmt_symbol.cxx: In class Symbol, in function create, suppress
     15        warning about set/macro <PACKAGE>ROOT for current package, in function
     16        action, use mangled package prefix with scripts, in function print_clean,
     17        use mangled set, path names with corresponding message, and quoted path,
     18        script values for cleanup scripts, in function print, use mangled set, path
     19        names with corresponding message, and quoted script values for setup
     20        scripts. In class SymbolValueList, in function print, output CMT package
     21        symbols as well
     22        * source/cmt.h: In class Cmt, introduce universal function install_scripts
     23        for both types of scripts, and function get_cmt_flags working on file, drop
     24        functions install_test_cleanup_scripts, install_test_setup_scripts
     25        * source/cmt_parser.cxx: In class Cmt, in functions do_config, do_relocate,
     26        retrieve cmtflags from input requirements file and current cmtflags, if any,
     27        and pass them to universal function install_scripts, in function do_setup,
     28        output cmtflags in Requirements mode inverting -with(out)_cmt, implement
     29        function get_cmt_flags working on file, universal function install_scripts,
     30        move static function mangle to class CmtSystem, in functions print_clean,
     31        print_context, use mangled package prefix in cleanup, setup scripts, in
     32        function set_standard_macros, create StandardMacroBuilder instance for
     33        Use::current (rather than Me). In class StandardMacroBuilder, in constructor,
     34        do not invoke pwd, in functions fill_for_package, fill_for_current_package,
     35        do not use argument, in function fill_for_branches, do not use pwd.
     36       
    1372011-03-22    <rybkin@lal.in2p3.fr> 447
    238
  • CMT/HEAD/source/cmt.h

    r561 r565  
    233233  static void get_cmt_flags (CmtSystem::cmt_string_vector& flags);
    234234  static cmt_string get_cmt_flags ();
     235  static cmt_string get_cmt_flags (const cmt_string& file_name);
    235236  static bool set_cmt_flags (const cmt_string& flags);
    236237  static bool add_cmt_flag (const cmt_string& flag);
     
    241242  static void install_cleanup_scripts ();
    242243  static void install_setup_scripts ();
     244  static void install_scripts (ScriptType type, const cmt_string& flags);
    243245  static void install_native_version_file ();
    244   static void install_test_cleanup_scripts ();
    245   static void install_test_setup_scripts ();
    246246  //  static bool load (const cmt_string& path,
    247247  static bool load (const ArgParser& ap,
  • CMT/HEAD/source/cmt_awk.cxx

    r542 r565  
    462462  cmt_string text;
    463463
    464   text.read (file_name);
     464  if (!text.read (file_name)) return (failed);
    465465
    466466  return (Awk::run (text, pattern));
     
    478478  cmt_string text;
    479479
    480   text.read (file_name);
     480  if (!text.read (file_name)) return (failed);
    481481
    482482  return (Awk::run (text, expression));
  • CMT/HEAD/source/cmt_commands.cxx

    r562 r565  
    21932193{
    21942194  cmt.m_use_cmt = true;
     2195  if (!Cmt::add_cmt_flag ("-with_cmt"))
     2196    CmtMessage::error ("Cannot add flag `-with_cmt'");
    21952197}
    21962198
     
    21982200{
    21992201  cmt.m_use_cmt = false;
     2202  if (!Cmt::add_cmt_flag ("-without_cmt"))
     2203    CmtMessage::error ("Cannot add flag `-without_cmt'");
    22002204}
    22012205
  • CMT/HEAD/source/cmt_install_area.cxx

    r459 r565  
    197197  cmt_string installarea;
    198198
    199   const cmt_string pwd = CmtSystem::pwd ();
    200 
    201   installarea = Project::find_in_cmt_paths (pwd);
     199  const Use& use = Use::current ();
     200  cmt_string current_path (use.real_path);
     201  if (!use.located ())
     202    {
     203      CmtMessage::verbose ("build_current_installarea: Current use not located");
     204      current_path = CmtSystem::pwd ();
     205    }
     206  //const cmt_string pwd = CmtSystem::pwd ();
     207
     208  installarea = Project::find_in_cmt_paths (current_path);
     209  //installarea = Project::find_in_cmt_paths (pwd);
    202210
    203211  return (installarea);
  • CMT/HEAD/source/cmt_parser.cxx

    r564 r565  
    28262826  if (Me.m_current_package == "methods") return;
    28272827
     2828  cmt_string file_name;
     2829  if (strlen (ap.extra_file.c_str ()) == 0)
     2830    file_name = "requirements";
     2831  else
     2832    file_name = ap.extra_file;
     2833  cmt_string cmtflags (get_cmt_flags (file_name));
     2834
     2835  if (strlen (ap.extra_file.c_str ()) != 0)
     2836    cmtflags += " -f=" + file_name;
     2837  cmt_string flags (get_cmt_flags ());
     2838  if (flags.size () != 0)
     2839    cmtflags += " " + flags;
     2840
    28282841  cmt_string branch;
    28292842
     
    28482861            }
    28492862
    2850           install_setup_scripts ();
    2851           install_cleanup_scripts ();
    2852           //install_test_setup_scripts ();
    2853           //install_test_cleanup_scripts ();
     2863          install_scripts (SetupScript, cmtflags);
     2864          install_scripts (CleanupScript, cmtflags);
     2865          //install_setup_scripts ();
     2866          //install_cleanup_scripts ();
    28542867
    28552868          Generator::build_default_makefile ();
     
    29592972  */
    29602973  Me.m_quiet = true;
    2961   install_setup_scripts ();
    2962   install_cleanup_scripts ();
     2974  install_scripts (SetupScript, cmtflags);
     2975  install_scripts (CleanupScript, cmtflags);
     2976  //install_setup_scripts ();
     2977  //install_cleanup_scripts ();
    29632978  install_native_version_file ();
    29642979
     
    30243039  if (Me.m_current_package == "methods") return;
    30253040
     3041  cmt_string file_name;
     3042  if (strlen (ap.extra_file.c_str ()) == 0)
     3043    file_name = "requirements";
     3044  else
     3045    file_name = ap.extra_file;
     3046  cmt_string cmtflags (get_cmt_flags (file_name));
     3047
     3048  if (strlen (ap.extra_file.c_str ()) != 0)
     3049    cmtflags += " -f=" + file_name;
     3050  cmt_string flags (get_cmt_flags ());
     3051  if (flags.size () != 0)
     3052    cmtflags += " " + flags;
     3053
    30263054  cmt_string branch;
    30273055
     
    30453073          cout << "------------------------------------------" << endl;
    30463074            }
    3047           install_setup_scripts ();
    3048           install_cleanup_scripts ();
    3049           //install_test_setup_scripts ();
    3050           //install_test_cleanup_scripts ();
     3075          install_scripts (SetupScript, cmtflags);
     3076          install_scripts (CleanupScript, cmtflags);
     3077          //install_setup_scripts ();
     3078          //install_cleanup_scripts ();
    30513079
    30523080          Generator::build_default_makefile ();
     
    30723100  //  Generator::build_default_makefile ();
    30733101 
     3102  /*
    30743103  CmtSystem::cd ("..");   
    30753104  CmtSystem::cd (branch);
     
    30953124      return;
    30963125    }
    3097 
    3098   install_setup_scripts ();
    3099   install_cleanup_scripts ();
     3126  */
     3127  Me.m_quiet = true;
     3128  install_scripts (SetupScript, cmtflags);
     3129  install_scripts (CleanupScript, cmtflags);
     3130  //install_setup_scripts ();
     3131  //install_cleanup_scripts ();
    31003132
    31013133  Generator::build_default_makefile ();
     
    41094141      cout << "<setup>";
    41104142      break;
     4143    case Requirements :
     4144      CmtSystem::cmt_string_vector flags;
     4145      get_cmt_flags (flags);
     4146      cout << "\n# CMTFLAGS: -without_cmt";
     4147      for (int i = 0; i < flags.size (); i++)
     4148        {
     4149          if (flags[i] == "-without_cmt")
     4150            cout << " -with_cmt";
     4151          else if (flags[i] == "-with_cmt")
     4152            cout << " -without_cmt";
     4153          else
     4154            cout << " " << flags[i];
     4155        }
     4156      cout << endl;
     4157      break;
    41114158    }
    41124159  print (ap.mode);
     
    50575104
    50585105//----------------------------------------------------------
     5106class CmtFlagsReader : public FAwk
     5107{
     5108public:
     5109
     5110  CmtFlagsReader ()
     5111  { }
     5112 
     5113  CmtFlagsReader (const cmt_string& pattern)
     5114    : m_pattern (pattern)
     5115  { m_condition = ok; }
     5116 
     5117  const cmt_string& get_pattern () const
     5118  {
     5119    return (m_pattern);
     5120  }
     5121 
     5122  const cmt_string& get_cmt_flags () const
     5123  {
     5124    return (m_cmt_flags);
     5125  }
     5126 
     5127  void filter (const cmt_string& line)
     5128  {
     5129    int p (line.find (m_pattern));
     5130    if (p == cmt_string::npos) return;
     5131    if (m_cmt_flags.size () != 0)
     5132      m_cmt_flags += " " + line.substr (p + m_pattern.size ());
     5133    else
     5134      m_cmt_flags = line.substr (p + m_pattern.size ());
     5135    //stop ();
     5136  }
     5137 
     5138private:
     5139  const cmt_string m_pattern;
     5140  cmt_string m_cmt_flags;
     5141};
     5142
     5143//----------------------------------------------------------
     5144cmt_string Cmt::get_cmt_flags (const cmt_string& file_name)
     5145{
     5146  cmt_string result;
     5147  CmtFlagsReader reader ("CMTFLAGS:");
     5148  Awk::condition c = reader.run (file_name, reader.get_pattern ());
     5149  if (Awk::failed != c)
     5150    result = reader.get_cmt_flags ();
     5151  else
     5152    CmtError::set (CmtError::file_access_error, file_name);
     5153  return result;
     5154}
     5155
     5156//----------------------------------------------------------
    50595157bool Cmt::set_cmt_flags (const cmt_string& cmtflags)
    50605158{
     
    52545352
    52555353//----------------------------------------------------------
    5256 //  Mangle text so that it consists solely of
    5257 //  letters, numbers, and underscores
    5258 //  (any other characters are replaced with X).
    5259 //  Then text, prefixed with a letter or underscore,
    5260 //  can be used as shell variable name
    5261 //----------------------------------------------------------
    5262 static cmt_string mangle (const cmt_string& text)
    5263 {
    5264   cmt_string result;
    5265   int allocated = text.size ();
    5266   char* const buffer = (char*) malloc (allocated + 1);
    5267   char* b (buffer);
    5268   const char* t = text.c_str ();
    5269   while (*t)
    5270     {
    5271       if (isalnum (*t) || *t == '_')
    5272         *b++ = *t++;
    5273       else
    5274         {
    5275           *b++ = 'X'; t++;
    5276         }
    5277     }
    5278   *b = '\0';
    5279   result = buffer;
    5280   free (buffer);
    5281   return result;
    5282 }
    5283 
    5284 //----------------------------------------------------------
    52855354void Cmt::install_cleanup_scripts ()
    52865355{
     
    53225391  cmt_string version = Me.m_current_version;
    53235392  if (version == "v*") version = "";
    5324   cmt_string mangled_package = mangle (Me.m_current_package);
     5393  cmt_string mangled_package = CmtSystem::mangle (Me.m_current_package);
    53255394
    53265395  for (i = 0; i < modes; i++)
     
    54795548  cmt_string version = Me.m_current_version;
    54805549  if (version == "v*") version = "";
    5481   cmt_string mangled_package = mangle (Me.m_current_package);
     5550  cmt_string mangled_package = CmtSystem::mangle (Me.m_current_package);
    54825551
    54835552  for (i = 0; i < modes; i++)
     
    56095678
    56105679//----------------------------------------------------------
    5611 void Cmt::install_test_cleanup_scripts ()
     5680void Cmt::install_scripts (ScriptType type, const cmt_string& flags)
    56125681{
    56135682#ifdef WIN32
     
    56225691
    56235692  Use& current_use = Use::current ();
    5624 
     5693  const cmt_string action = (SetupScript == type ? "setup" : "cleanup");
    56255694  if (!current_use.get_strategy ("SetupScripts"))
    56265695    {
    56275696      for (int i = 0; i < modes; i++)
    56285697        {
    5629           cmt_string old_file_name = "cleanup";
     5698          cmt_string old_file_name (action);
     5699          //cmt_string old_file_name = "setup";
    56305700          old_file_name += ".";
    56315701          old_file_name += suffix[i];
     
    56335703            {
    56345704              if (CmtMessage::active (Error))
    5635                 cerr << "Removing cleanup script " + old_file_name << endl;
     5705                cerr << "Removing " + action + " script " + old_file_name << endl;
     5706              //cerr << "Removing setup script " + old_file_name << endl;
    56365707              CmtSystem::remove_file (old_file_name);
    56375708            }
     
    56415712
    56425713  if (CmtMessage::active (Error))
    5643     cerr << "Creating cleanup scripts." << endl;
    5644 
    5645   cmt_string temp;
    5646   int i;
     5714    cerr << "Creating " + action + " scripts." << endl;
     5715  //cerr << "Creating setup scripts." << endl;
     5716 
     5717  cmt_string no_cleanup_opt;
     5718
     5719  if (SetupScript == type)
     5720    if (current_use.get_strategy ("SetupCleanup"))
     5721      {
     5722        no_cleanup_opt = " -no_cleanup";
     5723      }
     5724
     5725  no_cleanup_opt = flags + no_cleanup_opt;
    56475726
    56485727  cmt_string version = Me.m_current_version;
    56495728  if (version == "v*") version = "";
    5650   cmt_string mangled_package = mangle (Me.m_current_package);
    5651 
    5652   for (i = 0; i < modes; i++)
    5653     {
    5654       cmt_string file_name = "cleanup";
     5729  cmt_string mangled_package = CmtSystem::mangle (Me.m_current_package);
     5730
     5731  for (int i = 0; i < modes; i++)
     5732    {
     5733      cmt_string file_name = action;
     5734      //cmt_string file_name = "setup";
    56555735      file_name += ".";
    56565736      file_name += suffix[i];
     
    56635743          if (mode[i] == Csh)
    56645744            {
     5745              //fprintf (f, "# echo \"Setting %s %s in %s\"\n",
     5746              fprintf (f, "# echo \"%s %s %s in %s\"\n",
     5747                       action.c_str (),
     5748                       Me.m_current_package.c_str (),
     5749                       version.c_str (),
     5750                       Me.m_current_path.c_str ());
     5751              fprintf (f, "\n");
     5752
    56655753              fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
    56665754              fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
     
    56695757              fprintf (f, "set cmt%stempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n", mangled_package.c_str ());
    56705758              fprintf (f, "if $status != 0 then\n  set cmt%stempfile=/tmp/cmt.$$\nendif\n", mangled_package.c_str ());
    5671               fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${cmt%stempfile}\n",
    5672                        suffix[i].c_str (),
    5673                        Me.m_current_path.c_str (), mangled_package.c_str ());
     5759              //fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
     5760              fprintf (f, "${CMTROOT}/mgr/cmt %s -%s "
     5761                       "-pack=%s -version=%s -path=%s %s $* >${cmt%stempfile}\n",
     5762                       action.c_str (),
     5763                       suffix[i].c_str (),
     5764                       Me.m_current_package.c_str (),
     5765                       version.c_str (),
     5766                       Me.m_current_path.c_str (),
     5767                       no_cleanup_opt.c_str (),
     5768                       mangled_package.c_str ());
    56745769              fprintf (f,
    56755770                       "if ( $status != 0 ) then\n"
    5676                        "  echo \"${CMTROOT}/mgr/cmt cleanup -%s "
    5677                        "-pack=cmt_standalone -path=%s $* >${cmt%stempfile}\"\n"
    5678                        "  set cmtcleanupstatus=2\n"
     5771                       "  echo \"${CMTROOT}/mgr/cmt %s -%s "
     5772                       "-pack=%s -version=%s -path=%s %s $* >${cmt%stempfile}\"\n"
     5773                       "  set cmt%sstatus=2\n"
    56795774                       "  /bin/rm -f ${cmt%stempfile}\n"
    56805775                       "  unset cmt%stempfile\n"
    5681                        "  exit $cmtcleanupstatus\n"
     5776                       "  exit $cmt%sstatus\n"
    56825777                       "endif\n"
    5683                        "set cmtcleanupstatus=0\n"
     5778                       "set cmt%sstatus=0\n"
    56845779                       "source ${cmt%stempfile}\n"
    56855780                       "if ( $status != 0 ) then\n"
    5686                        "  set cmtcleanupstatus=2\n"
     5781                       "  set cmt%sstatus=2\n"
    56875782                       "endif\n"
    56885783                       "/bin/rm -f ${cmt%stempfile}\n"
    56895784                       "unset cmt%stempfile\n"
    5690                        "exit $cmtcleanupstatus\n",
     5785                       "exit $cmt%sstatus\n",
     5786                       action.c_str (),
    56915787                       suffix[i].c_str (),
    5692                        Me.m_current_path.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str ());
     5788                       Me.m_current_package.c_str (),
     5789                       version.c_str (),
     5790                       Me.m_current_path.c_str (),
     5791                       no_cleanup_opt.c_str (), mangled_package.c_str (),
     5792                       action.c_str (),
     5793                       mangled_package.c_str (),
     5794                       mangled_package.c_str (),
     5795                       action.c_str (),
     5796                       action.c_str (),
     5797                       mangled_package.c_str (),
     5798                       action.c_str (),
     5799                       mangled_package.c_str (),
     5800                       mangled_package.c_str (),
     5801                       action.c_str ());
    56935802            }
    56945803          else if (mode[i] == Sh)
    56955804            {
     5805              //fprintf (f, "# echo \"Setting %s %s in %s\"\n",
     5806              fprintf (f, "# echo \"%s %s %s in %s\"\n",
     5807                       action.c_str (),
     5808                       Me.m_current_package.c_str (),
     5809                       version.c_str (),
     5810                       Me.m_current_path.c_str ());
     5811              fprintf (f, "\n");
     5812
    56965813              fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
    56975814              fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
     
    57005817              fprintf (f, "cmt%stempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n", mangled_package.c_str ());
    57015818              fprintf (f, "if test ! $? = 0 ; then cmt%stempfile=/tmp/cmt.$$; fi\n", mangled_package.c_str ());
    5702               fprintf (f, "${CMTROOT}/mgr/cmt cleanup -%s -pack=cmt_standalone -path=%s $* >${cmt%stempfile}\n",
    5703                        suffix[i].c_str (),
    5704                        Me.m_current_path.c_str (), mangled_package.c_str ());
     5819              //fprintf (f, "${CMTROOT}/mgr/cmt setup -%s "
     5820              fprintf (f, "${CMTROOT}/mgr/cmt %s -%s "
     5821                       "-pack=%s -version=%s -path=%s %s $* >${cmt%stempfile}\n",
     5822                       action.c_str (),
     5823                       suffix[i].c_str (),
     5824                       Me.m_current_package.c_str (),
     5825                       version.c_str (),
     5826                       Me.m_current_path.c_str (),
     5827                       no_cleanup_opt.c_str (),
     5828                       mangled_package.c_str ());
    57055829              fprintf (f,
    57065830                       "if test $? != 0 ; then\n"
    5707                        "  echo >&2 \"${CMTROOT}/mgr/cmt cleanup -%s "
    5708                        "-pack=cmt_standalone -path=%s $* >${cmt%stempfile}\"\n"
    5709                        "  cmtcleanupstatus=2\n"
     5831                       "  echo >&2 \"${CMTROOT}/mgr/cmt %s -%s "
     5832                       "-pack=%s -version=%s -path=%s %s $* >${cmt%stempfile}\"\n"
     5833                       "  cmt%sstatus=2\n"
    57105834                       "  /bin/rm -f ${cmt%stempfile}\n"
    57115835                       "  unset cmt%stempfile\n"
    5712                        "  return $cmtcleanupstatus\n"
     5836                       "  return $cmt%sstatus\n"
    57135837                       "fi\n"
    5714                        "cmtcleanupstatus=0\n"
     5838                       "cmt%sstatus=0\n"
    57155839                       ". ${cmt%stempfile}\n"
    57165840                       "if test $? != 0 ; then\n"
    5717                        "  cmtcleanupstatus=2\n"
     5841                       "  cmt%sstatus=2\n"
    57185842                       "fi\n"
    57195843                       "/bin/rm -f ${cmt%stempfile}\n"
    57205844                       "unset cmt%stempfile\n"
    5721                        "return $cmtcleanupstatus\n",
     5845                       "return $cmt%sstatus\n",
     5846                       action.c_str (),
    57225847                       suffix[i].c_str (),
    5723                        Me.m_current_path.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str ());
     5848                       Me.m_current_package.c_str (),
     5849                       version.c_str (),
     5850                       Me.m_current_path.c_str (),
     5851                       no_cleanup_opt.c_str (), mangled_package.c_str (),
     5852                       action.c_str (),
     5853                       mangled_package.c_str (),
     5854                       mangled_package.c_str (),
     5855                       action.c_str (),
     5856                       action.c_str (),
     5857                       mangled_package.c_str (),
     5858                       action.c_str (),
     5859                       mangled_package.c_str (),
     5860                       mangled_package.c_str (),
     5861                       action.c_str ());
    57245862            }
    57255863          else if (mode[i] == Bat)
    57265864            {
     5865              //fprintf (f, "rem Setting %s %s in %%~d0%%~p0\n",
     5866              fprintf (f, "rem %s %s %s in %%~d0%%~p0\n",
     5867                       action.c_str (),
     5868                       Me.m_current_package.c_str (),
     5869                       version.c_str ());
    57275870              dos_script_prefix (f, Me.m_cmt_root,
    5728                                  "cmt_standalone", "cmt_standalone", "", Me.m_current_path,
    5729                                  "cleanup");
     5871                                 Me.m_current_package, mangled_package, version, Me.m_current_path,
     5872                                 action, no_cleanup_opt);
     5873              //"setup", no_cleanup_opt);
    57305874            }
    57315875
     
    57355879          //          fclose (f);
    57365880
    5737           cmt_string old_file_name = "cleanup";
     5881          cmt_string old_file_name = action;
     5882          //cmt_string old_file_name = "setup";
    57385883          old_file_name += ".";
    57395884          old_file_name += suffix[i];
     
    57795924        }
    57805925    }   
    5781 }
    5782 //----------------------------------------------------------
    5783 void Cmt::install_test_setup_scripts ()
    5784 {
    5785 #ifdef WIN32
    5786   static const int modes = 1;
    5787   static const cmt_string suffix[1]   = {"bat"};
    5788   static const PrintMode  mode[1]     = {Bat};
    5789 #else
    5790   static const int modes = 2;
    5791   static const cmt_string suffix[2]   = {"csh", "sh"};
    5792   static const PrintMode  mode[2]     = {Csh, Sh};
    5793 #endif
    5794 
    5795   Use& current_use = Use::current ();
    5796 
    5797   if (!current_use.get_strategy ("SetupScripts"))
    5798     {
    5799       for (int i = 0; i < modes; i++)
    5800         {
    5801           cmt_string old_file_name = "setup";
    5802           old_file_name += ".";
    5803           old_file_name += suffix[i];
    5804           if (CmtSystem::test_file (old_file_name))
    5805             {
    5806               if (CmtMessage::active (Error))
    5807                 cerr << "Removing setup script " + old_file_name << endl;
    5808               CmtSystem::remove_file (old_file_name);
    5809             }
    5810         }
    5811       return;
    5812     }
    5813 
    5814   if (CmtMessage::active (Error))
    5815     cerr << "Creating setup scripts." << endl;
    5816 
    5817   cmt_string no_cleanup_opt;
    5818 
    5819   if (current_use.get_strategy ("SetupCleanup"))
    5820     {
    5821       no_cleanup_opt = " -no_cleanup";
    5822     }
    5823 
    5824   cmt_string temp;
    5825   int i;
    5826 
    5827   cmt_string version = Me.m_current_version;
    5828   if (version == "v*") version = "";
    5829   cmt_string mangled_package = mangle (Me.m_current_package);
    5830 
    5831   for (i = 0; i < modes; i++)
    5832     {
    5833       cmt_string file_name = "setup";
    5834       file_name += ".";
    5835       file_name += suffix[i];
    5836       file_name += ".";
    5837       file_name += "new";
    5838 
    5839       FILE* f = fopen (file_name.c_str (), "wb");
    5840       if (f != NULL)
    5841         {
    5842           if (mode[i] == Csh)
    5843             {
    5844               fprintf (f, "# echo \"Setting standalone package\"\n");
    5845               fprintf (f, "\n");
    5846 
    5847               fprintf (f, "if ( $?CMTROOT == 0 ) then\n");
    5848               fprintf (f, "  setenv CMTROOT %s\n", Me.m_cmt_root.c_str ());
    5849               fprintf (f, "endif\n");
    5850               fprintf (f, "source ${CMTROOT}/mgr/setup.csh\n");
    5851               fprintf (f, "set cmt%stempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n", mangled_package.c_str ());
    5852               fprintf (f, "if $status != 0 then\n  set cmt%stempfile=/tmp/cmt.$$\nendif\n", mangled_package.c_str ());
    5853               fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${cmt%stempfile}\n",
    5854                        suffix[i].c_str (),
    5855                        Me.m_current_path.c_str (),
    5856                        no_cleanup_opt.c_str (), mangled_package.c_str ());
    5857               fprintf (f,
    5858                        "if ( $status != 0 ) then\n"
    5859                        "  echo \"${CMTROOT}/mgr/cmt setup -%s "
    5860                        "-pack=cmt_standalone -path=%s %s $* >${cmt%stempfile}\"\n"
    5861                        "  set cmtsetupstatus=2\n"
    5862                        "  /bin/rm -f ${cmt%stempfile}\n"
    5863                        "  unset cmt%stempfile\n"
    5864                        "  exit $cmtsetupstatus\n"
    5865                        "endif\n"
    5866                        "set cmtsetupstatus=0\n"
    5867                        "source ${cmt%stempfile}\n"
    5868                        "if ( $status != 0 ) then\n"
    5869                        "  set cmtsetupstatus=2\n"
    5870                        "endif\n"
    5871                        "/bin/rm -f ${cmt%stempfile}\n"
    5872                        "unset cmt%stempfile\n"
    5873                        "exit $cmtsetupstatus\n",
    5874                        suffix[i].c_str (),
    5875                        Me.m_current_path.c_str (),
    5876                        no_cleanup_opt.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str ());
    5877             }
    5878           else if (mode[i] == Sh)
    5879             {
    5880               fprintf (f, "# echo \"Setting standalone package\"\n");
    5881               fprintf (f, "\n");
    5882 
    5883               fprintf (f, "if test \"${CMTROOT}\" = \"\"; then\n");
    5884               fprintf (f, "  CMTROOT=%s; export CMTROOT\n", Me.m_cmt_root.c_str ());
    5885               fprintf (f, "fi\n");
    5886               fprintf (f, ". ${CMTROOT}/mgr/setup.sh\n");
    5887               fprintf (f, "cmt%stempfile=`${CMTROOT}/mgr/cmt -quiet build temporary_name`\n", mangled_package.c_str ());
    5888               fprintf (f, "if test ! $? = 0 ; then cmt%stempfile=/tmp/cmt.$$; fi\n", mangled_package.c_str ());
    5889               fprintf (f, "${CMTROOT}/mgr/cmt setup -%s -pack=cmt_standalone -path=%s %s $* >${cmt%stempfile}\n",
    5890                        suffix[i].c_str (),
    5891                        Me.m_current_path.c_str (),
    5892                        no_cleanup_opt.c_str (), mangled_package.c_str ());
    5893               fprintf (f,
    5894                        "if test $? != 0 ; then\n"
    5895                        "  echo >&2 \"${CMTROOT}/mgr/cmt setup -%s "
    5896                        "-pack=cmt_standalone -path=%s %s $* >${cmt%stempfile}\"\n"
    5897                        "  cmtsetupstatus=2\n"
    5898                        "  /bin/rm -f ${cmt%stempfile}\n"
    5899                        "  unset cmt%stempfile\n"
    5900                        "  return $cmtsetupstatus\n"
    5901                        "fi\n"
    5902                        "cmtsetupstatus=0\n"
    5903                        ". ${cmt%stempfile}\n"
    5904                        "if test $? != 0 ; then\n"
    5905                        "  cmtsetupstatus=2\n"
    5906                        "fi\n"
    5907                        "/bin/rm -f ${cmt%stempfile}\n"
    5908                        "unset cmt%stempfile\n"
    5909                        "return $cmtsetupstatus\n",
    5910                        suffix[i].c_str (),
    5911                        Me.m_current_path.c_str (),
    5912                        no_cleanup_opt.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str (), mangled_package.c_str ());
    5913             }
    5914           else if (mode[i] == Bat)
    5915             {
    5916               fprintf (f, "rem Setting standalone package\n");
    5917               dos_script_prefix (f, Me.m_cmt_root,
    5918                                  "cmt_standalone", "cmt_standalone", "", Me.m_current_path,
    5919                                  "setup", no_cleanup_opt);
    5920             }
    5921 
    5922           fprintf (f, "\n");
    5923 
    5924           CmtSystem::close_ostream (f, file_name);
    5925           //          fclose (f);
    5926 
    5927           cmt_string old_file_name = "setup";
    5928           old_file_name += ".";
    5929           old_file_name += suffix[i];
    5930 
    5931           CmtSystem::compare_and_update_files (file_name, old_file_name);
    5932         }
    5933       else
    5934         {
    5935           CmtError::set (CmtError::file_access_error, file_name);
    5936         }
    5937     }
    59385926}
    59395927
     
    73147302  set_standard_macros ();
    73157303
    7316   Script::all_print_clean (mode);
     7304  //Script::all_print_clean (mode);
    73177305  Symbol::all_print_clean (mode);
     7306
     7307  cmt_string prefix;
     7308  if (0 != CmtSystem::mangle (Me.m_current_prefix, prefix))
     7309    CmtMessage::verbose ("Replace " + Me.m_current_prefix + " with " + prefix);
    73187310
    73197311  switch (mode)
     
    73227314      if (Me.m_current_package != "CMT")
    73237315        {
    7324           cout << "unsetenv " << Me.m_current_prefix << "ROOT" << endl;
    7325           cout << "unsetenv " << Me.m_current_prefix << "CONFIG" << endl;
     7316          cout << "unsetenv " << prefix << "ROOT" << endl;
     7317          cout << "unsetenv " << prefix << "CONFIG" << endl;
    73267318        }
    73277319      break;
     
    73297321      if (Me.m_current_package != "CMT")
    73307322        {
    7331           cout << "unset " << Me.m_current_prefix << "ROOT" << endl;
    7332           cout << "unset " << Me.m_current_prefix << "CONFIG" << endl;
     7323          cout << "unset " << prefix << "ROOT" << endl;
     7324          cout << "unset " << prefix << "CONFIG" << endl;
    73337325        }
    73347326      break;
     
    73367328      if (Me.m_current_package != "CMT")
    73377329        {
    7338           cout << "set " << Me.m_current_prefix << "ROOT=" << endl;
    7339           cout << "set " << Me.m_current_prefix << "CONFIG=" << endl;
     7330          cout << "set " << prefix << "ROOT=" << endl;
     7331          cout << "set " << prefix << "CONFIG=" << endl;
    73407332        }
    73417333      break;
     
    73567348          if (p->is_cmt ()) continue;
    73577349
     7350
     7351          if (0 != CmtSystem::mangle (use->prefix, prefix))
     7352            CmtMessage::verbose ("Replace " + use->prefix + " with " + prefix);
    73587353
    73597354          switch (mode)
    73607355            {
    73617356            case Csh :
    7362               cout << "unsetenv " << use->prefix << "ROOT" << endl;
    7363               cout << "unsetenv " << use->prefix << "CONFIG" << endl;
     7357              cout << "unsetenv " << prefix << "ROOT" << endl;
     7358              cout << "unsetenv " << prefix << "CONFIG" << endl;
    73647359              break;
    73657360            case Sh :
    7366               cout << "unset " << use->prefix << "ROOT" << endl;
    7367               cout << "unset " << use->prefix << "CONFIG" << endl;
     7361              cout << "unset " << prefix << "ROOT" << endl;
     7362              cout << "unset " << prefix << "CONFIG" << endl;
    73687363              break;
    73697364            case Bat :
    7370               cout << "set " << use->prefix << "ROOT=" << endl;
    7371               cout << "set " << use->prefix << "CONFIG=" << endl;
     7365              cout << "set " << prefix << "ROOT=" << endl;
     7366              cout << "set " << prefix << "CONFIG=" << endl;
    73727367              break;
    73737368            }
     
    74057400  bool do_root   = use.get_strategy ("SetupRoot");
    74067401   
     7402  cmt_string prefix (use.prefix);
     7403  switch (mode)
     7404    {
     7405    case Requirements :
     7406      break;
     7407    default:
     7408      if (do_config || do_root)
     7409        {
     7410          if (0 != CmtSystem::mangle (use.prefix, prefix))
     7411            CmtMessage::verbose ("Replace " + use.prefix + " with " + prefix);
     7412        }
     7413      break;
     7414    }
    74077415 
    74087416  switch (mode)
     
    74117419      if (do_root)
    74127420        {
    7413           cout << "setenv " << use.prefix << "ROOT \"" <<
     7421          cout << "setenv " << prefix << "ROOT \"" <<
    74147422            use.get_full_path () << "\"" << endl;
    74157423        }
     
    74237431          if (do_config)
    74247432            {
    7425               cout << "setenv " << use.prefix << "CONFIG \"" << tag << "\"" << endl;
     7433              cout << "setenv " << prefix << "CONFIG \"" << tag << "\"" << endl;
    74267434            }
    74277435        }
     
    74317439      if (do_root)
    74327440        {
    7433           cout << use.prefix << "ROOT=\"" <<
     7441          cout << prefix << "ROOT=\"" <<
    74347442            use.get_full_path () << "\"; export " <<
    7435             use.prefix << "ROOT" << endl;
     7443            prefix << "ROOT" << endl;
    74367444        }
    74377445
     
    74447452          if (do_config)
    74457453            {
    7446               cout << use.prefix << "CONFIG=\"" <<
     7454              cout << prefix << "CONFIG=\"" <<
    74477455                tag << "\"; export " <<
    7448                 use.prefix << "CONFIG" << endl;
     7456                prefix << "CONFIG" << endl;
    74497457            }
    74507458        }
     
    74547462      if (do_root)
    74557463        {
    7456           cout << "set " << use.prefix << "ROOT=" <<
    7457             use.get_full_path () << endl;
     7464          cout << "set " << prefix << "ROOT=" <<
     7465            CmtSystem::quote (use.get_full_path (), " \t") << endl;
    74587466        }
    74597467
     
    74667474          if (do_config)
    74677475            {
    7468               cout << "set " << use.prefix << "CONFIG=" << tag << endl;
     7476              cout << "set " << prefix << "CONFIG=" << CmtSystem::quote (tag, " \t") << endl;
    74697477            }
    74707478        }
     
    74747482      if (do_root)
    74757483        {
    7476           cout << "<variable><name>" << use.prefix << "ROOT</name>"
     7484          cout << "<variable><name>" << prefix << "ROOT</name>"
    74777485               << "<value>" << use.get_full_path () << "</value></variable>";
    74787486        }
     
    74877495          if (do_config)
    74887496            {
    7489               cout << "<variable><name>" << use.prefix << "CONFIG</name>"
     7497              cout << "<variable><name>" << prefix << "CONFIG</name>"
    74907498                   << "<value>" << tag << "</value></variable>";
    74917499            }
     
    74977505          use.get_package_name () != "CMT")
    74987506        {
    7499           cout << "set " << use.prefix << "ROOT \"" <<
    7500             use.get_full_path () << "\"" << endl;
     7507          cout << "set " << use.prefix << "ROOT " <<
     7508            CmtSystem::quote (use.get_full_path (), " \t") << endl;
    75017509
    75027510          cmt_string name (use.prefix + "ROOT");
     
    75167524      if (use.get_package_name () == "CMT")
    75177525        {
    7518           cout << "set CMTCONFIG \"" << system << "\"" << endl;
     7526          cout << "set CMTCONFIG " << system << endl;
    75197527        }
    75207528      else
     
    75227530          if (do_config)
    75237531            {
    7524               cout << "set " << use.prefix << "CONFIG \"" << tag << "\"" << endl;
     7532              cout << "set " << use.prefix << "CONFIG " << CmtSystem::quote (tag, " \t") << endl;
    75257533            }
    75267534        }
     
    81148122    fs = CmtSystem::file_separator ();
    81158123    buffer = "";
    8116     pwd = CmtSystem::pwd ();
    8117     CmtSystem::split (pwd, fs, vb);
     8124    //pwd = CmtSystem::pwd ();
     8125    //CmtSystem::split (pwd, fs, vb);
    81188126    current_use = &(Use::current ());
    81198127    current_tag = tag;
     
    81618169   *   PACKAGE_ROOT
    81628170   */
    8163   void fill_for_package (const cmt_string& current_dir)
     8171  void fill_for_package ()
    81648172  {
    81658173    buffer = "macro package \"";
     
    82518259          }
    82528260
     8261        if (!Symbol::is_selected ("javabin"))
     8262          {
     8263            buffer = "macro javabin \".";
     8264            buffer += fs;
     8265            buffer += "\"";
     8266            apply ();
     8267          }
     8268
     8269        if (!Symbol::is_selected ("mgr"))
     8270          {
     8271            buffer = "macro mgr \".";
     8272            buffer += fs;
     8273            buffer += "\"";
     8274            apply ();
     8275          }
     8276
    82538277        if (!Symbol::is_selected ("BIN"))
    82548278          {
     
    82708294            else
    82718295              {
    8272                 atemp = pwd + fs + temp;
     8296                atemp = "$(PACKAGE_ROOT)";
     8297                Symbol::expand (atemp);
     8298                atemp += fs + temp;
     8299                //atemp = pwd + fs + temp;
    82738300                CmtSystem::compress_path (atemp);
    82748301              }
     
    82908317              }
    82918318          }
    8292 
    8293         if (!Symbol::is_selected ("javabin"))
    8294           {
    8295             buffer = "macro javabin \".";
    8296             buffer += fs;
    8297             buffer += "\"";
    8298             apply ();
    8299           }
    8300 
    8301         if (!Symbol::is_selected ("mgr"))
    8302           {
    8303             buffer = "macro mgr \".";
    8304             buffer += fs;
    8305             buffer += "\"";
    8306             apply ();
    8307           }
    83088319      }
    83098320    else
     
    83638374          }
    83648375
     8376        if (!Symbol::is_selected ("javabin"))
     8377          {
     8378            buffer = "macro javabin \"..";
     8379            buffer += fs;
     8380            buffer += "classes";
     8381            buffer += fs;
     8382            buffer += "\"";
     8383            apply ();
     8384          }
     8385       
     8386        if (current_style == mgr_style)
     8387          {
     8388            buffer = "macro mgrdir \"mgr\"";
     8389            apply ();
     8390
     8391            buffer = "macro mgr \"..";
     8392            buffer += fs;
     8393            buffer += "mgr";
     8394            buffer += fs;
     8395            buffer += "\"";
     8396            apply ();
     8397          }
     8398        else
     8399          {
     8400            buffer = "macro mgrdir \"cmt\"";
     8401            apply ();
     8402
     8403            buffer = "macro mgr \"..";
     8404            buffer += fs;
     8405            buffer += "cmt";
     8406            buffer += fs;
     8407            buffer += "\"";
     8408            apply ();
     8409          }
     8410
    83658411        if (!Symbol::is_selected ("BIN"))
    83668412          {
     
    83898435            else
    83908436              {
    8391                 atemp = pwd + fs + temp;
     8437                atemp = "$(PACKAGE_ROOT)";
     8438                atemp += fs + "$(mgrdir)";
     8439                Symbol::expand (atemp);
     8440                atemp += fs + temp;
     8441                //atemp = pwd + fs + temp;
    83928442                CmtSystem::compress_path (atemp);
    83938443              }
     
    84098459              }
    84108460          }
    8411 
    8412         if (!Symbol::is_selected ("javabin"))
    8413           {
    8414             buffer = "macro javabin \"..";
    8415             buffer += fs;
    8416             buffer += "classes";
    8417             buffer += fs;
    8418             buffer += "\"";
    8419             apply ();
    8420           }
    8421        
    8422         if (current_style == mgr_style)
    8423           {
    8424             buffer = "macro mgrdir \"mgr\"";
    8425             apply ();
    8426 
    8427             buffer = "macro mgr \"..";
    8428             buffer += fs;
    8429             buffer += "mgr";
    8430             buffer += fs;
    8431             buffer += "\"";
    8432             apply ();
    8433           }
    8434         else
    8435           {
    8436             buffer = "macro mgrdir \"cmt\"";
    8437             apply ();
    8438 
    8439             buffer = "macro mgr \"..";
    8440             buffer += fs;
    8441             buffer += "cmt";
    8442             buffer += fs;
    8443             buffer += "\"";
    8444             apply ();
    8445           }
    84468461
    84478462        Cmt::configure_current_cmtpath ();
     
    93549369   * and even before reading its requirements file.
    93559370   */
    9356   void fill_for_current_package (const cmt_string& current_dir)
     9371  void fill_for_current_package ()
    93579372  {
    93589373    fill_for_tag ();
    9359     fill_for_package (current_dir);
     9374    fill_for_package ();
    93609375  }
    93619376
     
    93639378  cmt_string fs;
    93649379  cmt_string buffer;
    9365   CmtSystem::cmt_string_vector vb;
    9366   cmt_string pwd;
     9380  //CmtSystem::cmt_string_vector vb;
     9381  //cmt_string pwd;
    93679382  Use* current_use;
    93689383  cmt_string current_tag;
     
    95059520
    95069521  StandardMacroBuilder builder (Me.m_current_tag,
    9507                                 Me.m_current_package,
    9508                                 Me.m_current_version,
    9509                                 Me.m_current_prefix,
    9510                                 Me.m_current_style);
    9511 
    9512 
    9513   builder.fill_for_current_package (Me.m_current_dir);
     9522                                current_use.get_package_name (),//Me.m_current_package,
     9523                                current_use.version,//Me.m_current_version,
     9524                                current_use.prefix,//Me.m_current_prefix,
     9525                                current_use.style);//Me.m_current_style);
     9526
     9527  builder.fill_for_current_package ();
    95149528
    95159529  builder.fill_for_branches ();
  • CMT/HEAD/source/cmt_project.cxx

    r563 r565  
    16521652cmt_string Project::find_in_cmt_paths (const cmt_string& path)
    16531653{
    1654   const cmt_string pwd = CmtSystem::pwd ();
     1654  //const cmt_string pwd = CmtSystem::pwd ();
    16551655
    16561656  // In case there are symlinks
  • CMT/HEAD/source/cmt_symbol.cxx

    r561 r565  
    774774                    break;
    775775                  }
    776 
    777                 CmtMessage::warning ("Symbol " + name
    778                                      + " inconsistently redeclared from " + s1
    779                                      + " to " + s2
    780                                      + ( (use != 0) ?
    781                                          " in package " + use->get_package_name () :
    782                                          "" )
    783                                      );
     776                // <PACKAGE>ROOT macro is defined in
     777                // Use::fill_standard_macros <- SyntaxParser::parse_requirements
     778                // "cmt -requirements setup" may generate <PACKAGE>ROOT set
     779                // hence, warning
     780                // Symbol <PACKAGE>ROOT inconsistently redeclared from macro to set in package <package>
     781                // below, we suppress the warning for current package
     782                if (use != &(Use::current()) ||
     783                    (Use::current().prefix + "ROOT") != name ||
     784                    symbol->type != SymbolMacro ||
     785                    type != SymbolSet)
     786                  CmtMessage::warning ("Symbol " + name
     787                                       + " inconsistently redeclared from " + s1
     788                                       + " to " + s2
     789                                       + ( (use != 0) ?
     790                                           " in package " + use->get_package_name () :
     791                                           "" )
     792                                       );
    784793                /*
    785794                cerr << "#CMT> Warning: Symbol " << name
     
    982991              full_name = "${";
    983992#endif
    984               full_name += use->prefix;
     993              full_name += CmtSystem::mangle (use->prefix);
    985994              full_name += "ROOT";
    986995#ifdef WIN32
     
    16121621  if (name == "CMTCONFIG") return (0);
    16131622
     1623  cmt_string _name;
     1624  switch (type)
     1625    {
     1626    case SymbolSet :
     1627    case SymbolPath :
     1628      if (0 != CmtSystem::mangle (name, _name))
     1629        CmtMessage::info ("Replace " + name + " with " + _name);
     1630      break;
     1631    }
     1632
    16141633  switch (type)
    16151634    {
     
    16181637        {
    16191638        case Csh :
    1620           cout << "unsetenv " << name;
     1639          cout << "unsetenv " << _name;
    16211640          result = 1;
    16221641          break;
    16231642        case Sh :
    1624           cout << "unset " << name;
     1643          cout << "unset " << _name;
    16251644          result = 1;
    16261645          break;
    16271646        case Bat :
    1628           cout << "set " << name << "=";
     1647          cout << "set " << _name << "=";
    16291648          result = 1;
    16301649          break;
     
    16511670          if (temp == "")
    16521671            {
    1653               cout << "unsetenv " << name;
     1672              cout << "unsetenv " << _name;
    16541673            }
    16551674          else
    16561675            {
    1657               cout << "setenv " << name << " " << temp;
     1676              cout << "setenv " << _name << " " << CmtSystem::quote (temp, " \t");
    16581677            }
    16591678          result = 1;
    16601679          break;
    16611680        case Sh :
    1662           cout << name << "=" << temp << "; export " << name;
     1681          cout << _name << "=" << CmtSystem::quote (temp, " \t") << "; export " << _name;
    16631682          result = 1;
    16641683          break;
    16651684        case Bat :
    1666           cout << "set " << name << "=" << temp;
     1685          cout << "set " << _name << "=" << CmtSystem::quote (temp, " \t");
    16671686          result = 1;
    16681687          break;
     
    16731692        {
    16741693        case Csh :
    1675           cout << "if ( -f " << name << ".csh ) then" << endl;
    1676           cout << "  source " << name << ".csh" << endl;
     1694          cout << "if ( -f " << CmtSystem::quote (name, " \t") << ".csh ) then" << endl;
     1695          cout << "  source " << CmtSystem::quote (name, " \t") << ".csh" << endl;
    16771696          cout <<
    16781697            "if ( $status != 0 ) then\n"
     
    16831702          break;
    16841703        case Sh :
    1685           cout << "if test -f " << name << ".sh; then" << endl;
    1686           cout << "  . " << name << ".sh" << endl;
     1704          cout << "if test -f " << CmtSystem::quote (name, " \t") << ".sh; then" << endl;
     1705          cout << "  . " << CmtSystem::quote (name, " \t") << ".sh" << endl;
    16871706          cout <<
    16881707            "if test $? != 0; then\n"
     
    16931712          break;
    16941713        case Bat :
    1695           cout << "call " << name;
     1714          cout << "call " << CmtSystem::quote (name, " \t");
    16961715          result = 1;
    16971716          break;
     
    17071726{
    17081727  int result = 0;
    1709   cmt_string temp;
    1710 
    1711   temp = build_macro_value ();
    1712 
     1728
     1729  cmt_string temp = build_macro_value ();
    17131730  bool empty = (temp.size () == 0) ? true : false;
    17141731
     
    17191736    }
    17201737
     1738  cmt_string _name;
    17211739  switch (type)
    17221740    {
    17231741      case SymbolSet :
    17241742      case SymbolPath :
     1743        if (0 != CmtSystem::mangle (name, _name))
     1744          CmtMessage::info ("Replace " + name + " with " + _name);
    17251745        switch (mode)
    17261746          {
    17271747            case Csh :
    1728               if (empty) cout << "unsetenv " << name;
    1729               else cout << "setenv " << name << " \"" << temp << "\"";
     1748              if (empty) cout << "unsetenv " << _name;
     1749              else cout << "setenv " << _name << " \"" << temp << "\"";
     1750              //else cout << "setenv " << name << " " << CmtSystem::quote (temp, " \t");
    17301751
    17311752              result = 1;
    17321753              break;
    17331754            case Sh :
    1734               if (empty) cout << "unset " << name;
    1735               else cout << name << "=\"" << temp << "\"; export " << name;
     1755              if (empty) cout << "unset " << _name;
     1756              else cout << _name << "=\"" << temp << "\"; export " << _name;
     1757              //else cout << name << "=" << CmtSystem::quote (temp, " \t") << "; export " << name;
    17361758
    17371759              result = 1;
     
    17391761            case Bat :
    17401762              temp.replace_all ("/", "\\");
    1741               cout << "set " << name << "=" << temp;
     1763              cout << "set " << _name << "=" << CmtSystem::quote (temp, " \t");
     1764              //cout << "set " << name << "=" << temp;
    17421765              result = 1;
    17431766              break;
    17441767            case Xml :
    1745               cout << "<variable><name>" << name << "</name>"
     1768              cout << "<variable><name>" << _name << "</name>"
    17461769                   << "<value>" << temp << "</value></variable>";
    17471770              result = 1;
     
    17541777            case Csh :
    17551778              cout << "alias " << name <<
    1756                   " \"" << temp << "\"";
     1779                " \"" << temp << "\"";
     1780              //CmtSystem::quote (temp, " \t");
    17571781              result = 1;
    17581782              break;
    17591783            case Sh :
    17601784              cout << "alias " << name <<
    1761                   "=\"" << temp << "\"";
     1785                "=\"" << temp << "\"";
     1786              //"=" << CmtSystem::quote (temp, " \t");
    17621787              result = 1;
    17631788              break;
    17641789            case Bat :
    17651790              cout << "set " << name <<
    1766                   "=" << temp;
     1791                "=" << CmtSystem::quote (temp, " \t");
     1792              //"=" << temp;
    17671793              result = 1;
    17681794              break;
     
    17861812              {
    17871813                case Csh :
    1788                   cout << "if ( -f " << name << ".csh ) then" << endl;
    1789                   cout << "  source " << name << ".csh" << endl;
     1814                  cout << "if ( -f " << CmtSystem::quote (name, " \t") << ".csh ) then" << endl;
     1815                  cout << "  source " << CmtSystem::quote (name, " \t") << ".csh" << endl;
    17901816                  cout <<
    17911817                    "if ( $status != 0 ) then\n"
     
    17961822                  break;
    17971823                case Sh :
    1798                   cout << "if test -f " << name << ".sh; then" << endl;
    1799                   cout << "  . " << name << ".sh" << endl;
     1824                  cout << "if test -f " << CmtSystem::quote (name, " \t") << ".sh; then" << endl;
     1825                  cout << "  . " << CmtSystem::quote (name, " \t") << ".sh" << endl;
    18001826                  cout <<
    18011827                    "if test $? != 0; then\n"
     
    18061832                  break;
    18071833                case Bat :
    1808                   cout << "call " << name;
     1834                  cout << "call " << CmtSystem::quote (name, " \t");
    18091835                  result = 1;
    18101836                  break;
     
    30673093  int result (0);
    30683094
    3069   if (use->get_package_name () == "CMT") return result;
     3095  //if (use->get_package_name () == "CMT") return result;
    30703096
    30713097  cmt_string discarded_text;
  • CMT/HEAD/source/cmt_system.cxx

    r561 r565  
    21882188  if (text.size () == 0) return result;
    21892189
    2190   int allocated = 3 * text.size (); // if EACH character of text quoted with " or '
     2190  size_t allocated = 3 * text.size (); // if EACH character of text quoted with " or '
    21912191  char* const buffer = (char*) malloc (allocated + 1);
     2192  if (0 == buffer)
     2193    {
     2194      char num[32]; sprintf (num, "%u", allocated + 1);
     2195      cmt_string msg ("Cannot allocate ");
     2196      msg += num;
     2197      msg += " bytes";
     2198      cmt_string e = errno ? ": " + cmt_string (strerror (errno)) : "";
     2199      CmtMessage::error (msg + e);
     2200      exit (EXIT_FAILURE);
     2201    }
    21922202  char* b (buffer);
    21932203
     
    22442254  result = buffer;
    22452255  free (buffer);
     2256  return result;
     2257}
     2258
     2259//----------------------------------------------------------
     2260//  Mangle text so that it consists solely of
     2261//  letters, digits, and underscores
     2262//  the first character being not digit
     2263//  (any other characters are replaced with character '_').
     2264//  The out can be used as shell variable name.
     2265//  Return the number of characters replaced with character '_'.
     2266//----------------------------------------------------------
     2267int CmtSystem::mangle (const cmt_string& text, cmt_string& out)
     2268{
     2269  int result (0);
     2270  size_t allocated = text.size ();
     2271  //allocated = 3000000000;
     2272  char* const buffer = (char*) malloc (allocated + 1);
     2273  if (0 == buffer)
     2274    {
     2275      char num[32]; sprintf (num, "%u", allocated + 1);
     2276      cmt_string msg ("Cannot allocate ");
     2277      msg += num;
     2278      msg += " bytes";
     2279      cmt_string e = errno ? ": " + cmt_string (strerror (errno)) : "";
     2280      CmtMessage::error (msg + e);
     2281      exit (EXIT_FAILURE);
     2282    }
     2283  char* b (buffer);
     2284  const char* t = text.c_str ();
     2285  while (*t)
     2286    {
     2287      if (isalnum (*t) || *t == '_')
     2288        *b++ = *t++;
     2289      else
     2290        {
     2291          *b++ = '_'; t++;
     2292          result++;
     2293        }
     2294    }
     2295  *b = '\0';
     2296  if (0 != allocated && isdigit (*buffer))
     2297    {
     2298      *buffer = '_';
     2299      result++;
     2300    }
     2301  out = buffer;
     2302  free (buffer);
     2303  return result;
     2304}
     2305
     2306cmt_string CmtSystem::mangle (const cmt_string& text)
     2307{
     2308  cmt_string result;
     2309  mangle (text, result);
    22462310  return result;
    22472311}
  • CMT/HEAD/source/cmt_system.h

    r561 r565  
    134134  static cmt_string quote (const cmt_string& text,
    135135                           const cmt_string& separators);
     136  static int mangle (const cmt_string& text, cmt_string& out);
     137  static cmt_string mangle (const cmt_string& text);
    136138
    137139  static void compress_path (const cmt_string& dir, cmt_string& new_dir);
Note: See TracChangeset for help on using the changeset viewer.