Changeset 565 for CMT/HEAD/source


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

See C.L. 448

Location:
CMT/HEAD/source
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • 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.