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

See C.L. 448

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 ();
Note: See TracChangeset for help on using the changeset viewer.