cmt_constituent.cxx Source File

Main Page Class Hierarchy Compound List File List Compound Members File Members

# cmt_constituent.cxx

Go to the documentation of this file.

    00001 #include <stdio.h>
    00002 #include <stdlib.h>
    00003 #include <string.h>
    00004 #include <ctype.h>
    00005
    00006 #include "cmt_constituent.h"
    00007 #include "cmt_generator.h"
    00008 #include "cmt_system.h"
    00009 #include "cmt_database.h"
    00010
    00011 /*----------------------------------------------------------*/
    00012 /*                                                          */
    00013 /*  Operations on Constituent                               */
    00014 /*                                                          */
    00015 /*----------------------------------------------------------*/
    00016
    00017 //----------------------------------------------------------
    00018 void Constituent::show (const cmt_string& name)
    00019 {
    00020   Constituent* cptr = find (name);
    00021   if (cptr == 0) return;
    00022
    00023   const Constituent& constituent = *cptr;
    00024
    00025   constituent.show ();
    00026 }
    00027
    00028 //----------------------------------------------------------
    00029 void Constituent::parse_all ()
    00030 {
    00031   static ConstituentVector& Constituents = constituents ();
    00032
    00033   int number;
    00034
    00035   for (number = 0; number < Constituents.size (); number++)
    00036     {
    00037       Constituent& constituent = Constituents[number];
    00038
    00039       constituent.parse ();
    00040     }
    00041 }
    00042
    00043 //----------------------------------------------------------
    00044 void Constituent::show_all ()
    00045 {
    00046   static ConstituentVector& Constituents = constituents ();
    00047
    00048   int number;
    00049
    00050   for (number = 0; number < Constituents.size (); number++)
    00051     {
    00052       const Constituent& constituent = Constituents[number];
    00053
    00054       constituent.show ();
    00055     }
    00056 }
    00057
    00058 //----------------------------------------------------------
    00059 void Constituent::show_names ()
    00060 {
    00061   static ConstituentVector& Constituents = constituents ();
    00062
    00063   int number;
    00064
    00065   for (number = 0; number < Constituents.size (); number++)
    00066     {
    00067       Constituent& constituent = Constituents[number];
    00068       cout << constituent.name << endl;
    00069     }
    00070 }
    00071
    00072 //----------------------------------------------------------
    00073 Constituent* Constituent::find (const cmt_string& name)
    00074 {
    00075   static ConstituentVector& Constituents = constituents ();
    00076
    00077   int constituent_index;
    00078
    00079   if (Constituents.size () == 0) return (0);
    00080
    00081   for (constituent_index = 0;
    00082        constituent_index < Constituents.size ();
    00083        constituent_index++)
    00084     {
    00085       Constituent& constituent = Constituents[constituent_index];
    00086
    00087       if (constituent.name == name)
    00088         {
    00089           return (&constituent);
    00090         }
    00091     }
    00092
    00093   return (0);
    00094 }
    00095
    00096 class constituents_action_iterator
    00097 {
    00098 public:
    00099   typedef enum
    00100   {
    00101     ready,
    00102     need_include
    00103   } states;
    00104
    00105   constituents_action_iterator (Constituent& c) : m_constituent (c)
    00106   {
    00107     m_state = ready;
    00108   }
    00109
    00110   void set (const cmt_string& w)
    00111   {
    00112     int equal;
    00113
    00114     if (w == "") return;
    00115
    00116     if (m_state == need_include)
    00117       {
    00118         m_state = ready;
    00119
    00120         cmt_string& include = m_constituent.includes.add ();
    00121         include = w;
    00122       }
    00123
    00124     if (w == "-OS9")
    00125       {
    00126         m_constituent.need_OS9 = true;
    00127       }
    00128     else if ((w == "-Windows") ||
    00129              (w == "-windows"))
    00130       {
    00131         m_constituent.windows = true;
    00132       }
    00133     else if (w == "-no_share")
    00134       {
    00135         m_constituent.no_share = true;
    00136       }
    00137     else if (w == "-no_static")
    00138       {
    00139         m_constituent.no_static = true;
    00140       }
    00141     else if (w == "-prototypes")
    00142       {
    00143         m_constituent.need_prototypes = true;
    00144       }
    00145     else if (w == "-no_prototypes")
    00146       {
    00147         m_constituent.need_prototypes = false;
    00148       }
    00149     else if (w == "-check")
    00150       {
    00151         m_constituent.need_check = true;
    00152       }
    00153     else if (w == "-triggers")
    00154       {
    00155         if (m_constituent.type == Library)
    00156           {
    00157               //m_constituent.build_triggers = true;
    00158           }
    00159       }
    00160     else if (w == "-no_triggers")
    00161       {
    00162         if (m_constituent.type == Library)
    00163           {
    00164             m_constituent.build_triggers = false;
    00165           }
    00166       }
    00167     else if (w == "-I")
    00168       {
    00169         m_state = need_include;
    00170       }
    00171     else if (w.substr (0, 3) == "-s=")
    00172       {
    00173         w.substr (3, m_subdir);
    00174       }
    00175     else if (w.substr (0, 8) == "-import=")
    00176       {
    00177         cmt_string& import = m_constituent.imports.add ();
    00178         w.substr (8, import);
    00179       }
    00180     else if (w.substr (0, 7) == "-group=")
    00181       {
    00182         cmt_string group_name = "";
    00183
    00184         w.substr (7, group_name);
    00185
    00186         m_constituent.group = Group::add (group_name);
    00187       }
    00188     else if (w.substr (0, 8) == "-suffix=")
    00189       {
    00190         w.substr (8, m_constituent.suffix);
    00191       }
    00192     else if ((equal = w.find ("=")) != cmt_string::npos)
    00193       {
    00194         cmt_string variable_name;
    00195         cmt_string variable_value;
    00196
    00197         w.substr (0, equal, variable_name);
    00198         w.substr (equal + 1, variable_value);
    00199
    00200         Variable* v = Variable::find (m_constituent.variables, variable_name);
    00201         if (v == 0)
    00202           {
    00203             v = &(m_constituent.variables.add ());
    00204             v->set (variable_name);
    00205           }
    00206
    00207         (*v) = variable_value;
    00208       }
    00209     else
    00210       {
    00211         // We have a normal source module
    00212
    00213         cmt_string& module = m_constituent.modules.add ();
    00214
    00215         module.erase (0);
    00216
    00217         //
    00218         // The prefix explicitly provided in (w) has priority
    00219         // over the currently specified (m_subdir) when it is an
    00220         // absolute path
    00221         //
    00222         if (CmtSystem::absolute_path (w))
    00223           {
    00224             module += w;
    00225           }
    00226         else
    00227           {
    00228             cmt_string prefix;
    00229             cmt_string name = w;
    00230
    00231             CmtSystem::dirname (name, prefix);
    00232             if (prefix == "../src") CmtSystem::basename (name, name);
    00233
    00234             module += m_subdir;
    00235
    00236             if (module != "")
    00237               {
    00238                 module += CmtSystem::file_separator ();
    00239               }
    00240
    00241             module += name;
    00242           }
    00243       }
    00244   }
    00245
    00246   Constituent& m_constituent;
    00247   cmt_string m_subdir;
    00248   states m_state;
    00249 };
    00250
    00251 //----------------------------------------------------------
    00252 void Constituent::action (ConstituentType type,
    00253                           const CmtSystem::cmt_string_vector& words)
    00254 {
    00255   cmt_string generator;
    00256   cmt_string name;
    00257   Constituent* constituent;
    00258
    00259   int i = 1;
    00260
    00261   if (type == Document)
    00262     {
    00263       generator = words[i];
    00264       if (generator == "") return;
    00265       i++;
    00266     }
    00267
    00268   name = words[i];
    00269   if (name == "") return;
    00270   i++;
    00271
    00272   constituent = add (type, name, generator);
    00273
    00274   for (;i < words.size (); i++)
    00275     {
    00276       const cmt_string& w = words[i];
    00277       cmt_string& parameter = constituent->parameters.add ();
    00278       parameter = w;
    00279     }
    00280 }
    00281
    00282 //----------------------------------------------------------
    00283 void Constituent::parse ()
    00284 {
    00285   if (parameters.size () == 0) return;
    00286
    00287   Constituent& me = *this;
    00288
    00289   modules.clear ();
    00290
    00291   constituents_action_iterator it (me);
    00292
    00293   for (int i = 0; i < parameters.size (); i++)
    00294     {
    00295       const cmt_string& w = parameters[i];
    00296       cmt_string ew = w;
    00297
    00298       Symbol::expand (ew);
    00299
    00300       CmtSystem::cmt_string_vector ws;
    00301
    00302       CmtSystem::split (ew, " \t", ws);
    00303
    00304       for (int j = 0; j < ws.size (); ++j)
    00305         {
    00306           const cmt_string& w = ws[j];
    00307
    00308             //cerr << "Constituent " << name << " Setting module " << w << endl;
    00309           it.set (w);
    00310         }
    00311     }
    00312
    00313   parameters.clear ();
    00314 }
    00315
    00316 //----------------------------------------------------------
    00317 Constituent* Constituent::add (ConstituentType type,
    00318                                const cmt_string& name,
    00319                                const cmt_string& generator)
    00320 {
    00321   static ConstituentVector& Constituents = constituents ();
    00322
    00323   {
    00324     Constituent* constituent;
    00325
    00326     if (name == "") return (0);
    00327
    00328     constituent = find (name);
    00329     if (constituent != 0) return (constituent);
    00330   }
    00331
    00332   Constituent& constituent = Constituents.add ();
    00333   constituent.clear ();
    00334
    00335   constituent.name      = name;
    00336   constituent.generator = generator;
    00337   constituent.type      = type;
    00338   constituent.need_prototypes = Cmt::need_prototypes ();
    00339
    00340   return (&constituent);
    00341 }
    00342
    00343
    00344 //----------------------------------------------------------
    00345 void Constituent::clear_all ()
    00346 {
    00347   static ConstituentVector& Constituents = constituents ();
    00348
    00349   for (int i = 0; i < Constituents.size (); i++)
    00350     {
    00351       Constituent& c = Constituents[i];
    00352       c.clear ();
    00353     }
    00354   Constituents.clear ();
    00355 }
    00356
    00357 //----------------------------------------------------------
    00358 Constituent::ConstituentVector& Constituent::constituents ()
    00359 {
    00360   static Database& db = Database::instance ();
    00361   static ConstituentVector& Constituents = db.constituents ();
    00362
    00363   return (Constituents);
    00364 }
    00365
    00366 //----------------------------------------------------------
    00367 Constituent::Constituent ()
    00368 {
    00369   clear ();
    00370 }
    00371
    00372 //----------------------------------------------------------
    00373 Constituent::~Constituent ()
    00374 {
    00375 }
    00376
    00377 //----------------------------------------------------------
    00378 void Constituent::clear ()
    00379 {
    00380   name      = "";
    00381   generator = "";
    00382   type = Document;
    00383   group     = 0;
    00384   modules.clear ();
    00385   parameters.clear ();
    00386   need_OS9        = false;
    00387   windows         = false;
    00388   no_static       = false;
    00389   no_share        = false;
    00390   need_prototypes = false;
    00391   need_check      = false;
    00392   build_triggers  = false;
    00393   includes.clear ();
    00394   imports.clear ();
    00395   variables.clear ();
    00396 }
    00397
    00398 //----------------------------------------------------------
    00399 void Constituent::build_all_makefiles (bool simulation)
    00400 {
    00401   static ConstituentVector& Constituents = constituents ();
    00402
    00403   int i;
    00404
    00405   for (i = 0; i < Constituents.size (); i++)
    00406     {
    00407       Constituent& constituent = Constituents[i];
    00408
    00409       constituent.build_makefile (simulation);
    00410     }
    00411 }
    00412
    00413 //----------------------------------------------------------
    00414 void Constituent::build_all_msdev_files (bool simulation)
    00415 {
    00416   static ConstituentVector& Constituents = constituents ();
    00417
    00418   int i;
    00419
    00420   Generator::build_msdev_workspace (Constituents);
    00421
    00422   for (i = 0; i < Constituents.size (); i++)
    00423     {
    00424       Constituent& constituent = Constituents[i];
    00425
    00426       constituent.build_msdev_file (simulation);
    00427     }
    00428 }
    00429
    00430 //----------------------------------------------------------
    00431 void Constituent::build_makefile (bool simulation) const
    00432 {
    00433   if (!simulation)
    00434     {
    00435       Generator::build_constituent_makefile (*this);
    00436     }
    00437     //else cout << command << endl;
    00438 }
    00439
    00440 //----------------------------------------------------------
    00441 void Constituent::build_msdev_file (bool simulation) const
    00442 {
    00443   if (!simulation)
    00444     {
    00445       Generator::build_msdev (*this);
    00446     }
    00447     //else cout << command << endl;
    00448 }
    00449
    00450 //----------------------------------------------------------
    00451 void Constituent::show () const
    00452 {
    00453   int i;
    00454
    00455   switch (type)
    00456     {
    00457       case Library:
    00458         cout << "library";
    00459         break;
    00460       case Application:
    00461         cout << "application";
    00462         break;
    00463       case Document:
    00464         cout << "document " << generator;
    00465         break;
    00466     }
    00467
    00468   cout << " " << name;
    00469
    00470   if (group != 0)
    00471     {
    00472       cout << " -group=" << group->name ();
    00473     }
    00474
    00475   if (suffix != 0)
    00476     {
    00477       cout << " -suffix=" << suffix;
    00478     }
    00479
    00480   if ((type == Application) && need_check)
    00481     {
    00482       cout << " -check";
    00483     }
    00484
    00485   if ((type == Library) && no_share)
    00486     {
    00487       cout << " -no_share";
    00488     }
    00489
    00490   if ((type == Library) && no_static)
    00491     {
    00492       cout << " -no_static";
    00493     }
    00494
    00495   if ((type == Library) && build_triggers)
    00496     {
    00497       cout << " -triggers";
    00498     }
    00499
    00500   for (i = 0; i < (imports.size ()); i++)
    00501     {
    00502       const cmt_string& import_name = imports[i];
    00503
    00504       cout << " -import=" << import_name;
    00505     }
    00506
    00507   for (i = 0; i < (modules.size ()); i++)
    00508     {
    00509       const cmt_string& module_name = modules[i];
    00510
    00511       cout << " " << module_name;
    00512     }
    00513
    00514   for (i = 0; i < (variables.size ()); i++)
    00515     {
    00516       const Variable& v = variables[i];
    00517
    00518       cout << " " << v.name << "=" << v.value;
    00519     }
    00520
    00521   cout << endl;
    00522 }