Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

StandardMacroBuilder Class Reference

This completely local class holds primitive actions for building standard macros. More...

Collaboration diagram for StandardMacroBuilder:

Collaboration graph
[legend]
List of all members.

Public Member Functions

void fill_for_CMTVERSION ()
 CMTVERSION.

 StandardMacroBuilder (const cmt_string &tag, const cmt_string &package, const cmt_string &version, const cmt_string &prefix, CmtDirStyle style)
void apply ()
void fill_for_tag ()
 tag

void fill_for_package (const cmt_string &current_dir)
 PACKAGE_ROOT.

void fill_for_branches ()
 srcdir src =/ inc mgrdir mgr =..// bin javabin doc version package

void fill_for_project ()
 project

void fill_for_use_requirements ()
 use_requirements

void fill_for_use_includes ()
 use_includes

void fill_for_use_fincludes ()
 use_fincludes

void fill_for_use_stamps ()
 use_stamps

void fill_for_use_cflags ()
 use_cflags

void fill_for_use_pp_cflags ()
 use_pp_cflags

void fill_for_use_cppflags ()
 use_cppflags

void fill_for_use_pp_cppflags ()
 use_pp_cppflags

void fill_for_use_fflags ()
 use_fflags

void fill_for_use_pp_fflags ()
 use_pp_fflags

void fill_for_use_linkopts ()
 use_linkopts

void fill_for_use_libraries ()
 use_libraries

void fill_for_includes ()
 includes

void fill_for_fincludes ()
 fincludes

void fill_for_all_constituents ()
 Macros specific to constituents.

void fill_for_constituent_macros ()
 Macros implied or required to manage constituents.

void fill_for_install_area ()
 Definitions for installation area mechanisms.

void fill_for_current_package (const cmt_string &current_dir)
 Macros to be defined once current_package is known and even before reading its requirements file.


Private Attributes

cmt_string fs
cmt_string buffer
CmtSystem::cmt_string_vector vb
cmt_string pwd
Usecurrent_use
cmt_string current_tag
cmt_string current_package
cmt_string current_version
cmt_string current_prefix
CmtDirStyle current_style

Detailed Description

This completely local class holds primitive actions for building standard macros.

Definition at line 6165 of file cmt_parser.cxx.


Constructor & Destructor Documentation

StandardMacroBuilder::StandardMacroBuilder const cmt_string tag,
const cmt_string package,
const cmt_string version,
const cmt_string prefix,
CmtDirStyle  style
[inline]
 

Definition at line 6180 of file cmt_parser.cxx.

References buffer, Use::current(), current_package, current_prefix, current_style, current_tag, current_use, current_version, CmtSystem::file_separator(), fs, CmtSystem::pwd(), pwd, CmtSystem::split(), and vb.

06185   {
06186     fs = CmtSystem::file_separator ();
06187     buffer = "";
06188     pwd = CmtSystem::pwd ();
06189     CmtSystem::split (pwd, fs, vb);
06190     current_use = &(Use::current ());
06191     current_tag = tag;
06192     current_package = package;
06193     current_version = version;
06194     current_prefix = prefix;
06195     current_style = style;
06196   }


Member Function Documentation

void StandardMacroBuilder::apply  )  [inline]
 

Definition at line 6198 of file cmt_parser.cxx.

References buffer, current_use, and SyntaxParser::parse_requirements_line().

Referenced by fill_for_all_constituents(), fill_for_branches(), fill_for_CMTVERSION(), fill_for_fincludes(), fill_for_includes(), fill_for_package(), fill_for_project(), fill_for_tag(), fill_for_use_cflags(), fill_for_use_cppflags(), fill_for_use_fflags(), fill_for_use_fincludes(), fill_for_use_includes(), fill_for_use_libraries(), fill_for_use_linkopts(), fill_for_use_pp_cflags(), fill_for_use_pp_cppflags(), fill_for_use_pp_fflags(), fill_for_use_requirements(), and fill_for_use_stamps().

06199   {
06200     SyntaxParser::parse_requirements_line (buffer, current_use);
06201     buffer = "";
06202   }

void StandardMacroBuilder::fill_for_all_constituents  )  [inline]
 

Macros specific to constituents.

This includes the compiler flags and fills in these macros from uses packages. This takes care of -no_auto_imports and -import= directives

_use_linkopts _<constituent>_cflags _<constituent>_pp_cflags _<constituent>_cppflags _<constituent>_pp_cppflags _<constituent>_fflags _<constituent>_pp_fflags linkopts _GUID

First, finish the parsing of constituent parameters.

Prepare the auto_imports states in a vector

Now scan all constituents

Problem for imports in constituents.

1) use_xxx has holes due to the corresponding -no_auto_imports options attached to some use statements (including the transitive ones)

2) the -import=yyy options provided to a given constituent should restore the appropriate holes as well as all transitive ones.

3) for use_linkopts, missing pieces must be filled at the right position. (for others, order is not relevant while transitive access is required for all)

Create a private copy of the state vector. This private copy will be updated according to -import=xxx modifiers for the current constituent.

Find all newly exposed packages and precompute this list inside a vector.

Setting ${CONSTITUENT}linkopts is a temporary solution until the backward compatibility solution for a proper replacement of use_linkopts by ${CONSTITUENT}_use_linkopts is acheived.

Only for linkopts we take care of the order. This means that ${CONSTITUENT}_use_linkopts should be used in place of use_linkopts.

(see the application fragments) that ${CONSTITUENT}_use_linkopts will be used in place of use_linkopts.

Definition at line 6783 of file cmt_parser.cxx.

References Application, apply(), Use::auto_imports, buffer, Constituent::constituents(), Constituent::ConstituentVector, current_use, Use::discarded, Document, Use::fill_includes_macro(), Use::fill_macro(), Use::find_index(), Cmt::get_debug(), Package::get_name(), Use::get_ordered_uses(), Use::get_package(), Constituent::imports, Package::is_cmt(), Library, Constituent::name, Off, Constituent::parse_all(), cmt_vector< T >::push_back(), cmt_vector< T >::resize(), Use::set_auto_imports_state(), cmt_vector< T >::size(), Constituent::type, and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06784   {
06786     Constituent::parse_all ();
06787 
06788     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06789 
06790     const Constituent::ConstituentVector& constituents =
06791       Constituent::constituents ();
06792 
06793   
06795 
06796     cmt_vector<bool> base_auto_imports_states;
06797 
06798     base_auto_imports_states.resize (Uses.size ());
06799 
06800     int number;
06801 
06802     for (number = 0; number < Uses.size (); number++)
06803       {
06804         Use* use = Uses[number];
06805         base_auto_imports_states[number] = (use->auto_imports != Off);
06806       }
06807 
06809 
06810     for (number = 0; number < constituents.size (); number++)
06811       {
06812         const Constituent& constituent = constituents[number];
06813 
06814         if (Cmt::get_debug ())
06815           {
06816             cout << "Checking " << constituent.name  << " against imports requests" << endl;
06817           }
06818 
06819         Use::UsePtrVector imports;
06820         int i;
06821 
06839         if (constituent.type == Document) continue;
06840         if (constituent.imports.size () == 0) 
06841           {
06842             buffer = "macro_append ";
06843             buffer += constituent.name;
06844             buffer += "_use_linkopts ";
06845             buffer += " \" ";
06846        
06847             current_use->fill_macro (buffer, "linkopts");
06848        
06849             for (i = 0; i < Uses.size (); i++)
06850               {
06851                 if (base_auto_imports_states[i])
06852                   {
06853                     Use* u = Uses[i];
06854                
06855                     if (u->discarded) continue;
06856 
06857                     Package* p = u->get_package ();
06858                     if (p->is_cmt ()) continue;
06859                     
06860                     u->fill_macro (buffer, "linkopts");
06861                   }
06862               }
06863             buffer += "\"";
06864             apply ();
06865 
06866           /*
06867             buffer = "macro_append ";
06868             buffer += constituent.name;
06869             buffer += "_use_linkopts ";
06870 
06871             buffer += " \" $(use_linkopts)\"";
06872             apply ();
06873             */
06874 
06875             continue;
06876           }
06877 
06883         cmt_vector<bool> auto_imports_states (base_auto_imports_states);
06884 
06885         for (i = 0; i < constituent.imports.size (); i++)
06886           {
06887             const cmt_string& import = constituent.imports[i];
06888             
06889             //
06890             // Resolve the imported uses
06891             //
06892 
06893             int use_index = Use::find_index (import, "", "");
06894 
06895             if (use_index >= 0)
06896               {
06897                 Use* u = Uses[use_index];
06898             
06899                 if (u->discarded) continue;
06900 
06901                 if (Cmt::get_debug ())
06902                   {
06903                     cout << constituent.name  << " needs imports " << import << " "
06904                          << use_index << " " 
06905                          << u->get_package()->get_name() << endl;
06906                   }
06907 
06908                 Package* p = u->get_package ();
06909                 if (p->is_cmt ()) continue;
06910 
06911                 if (u->auto_imports != Off) continue;
06912 
06913                 Use::set_auto_imports_state (use_index, auto_imports_states);
06914               }
06915           }
06916 
06917         if (Cmt::get_debug ())
06918           {
06919             cout << constituent.name  << " has imports " << endl;
06920           }
06921 
06922 
06927         for (i = 0; i < base_auto_imports_states.size (); i++)
06928           {
06929             if (auto_imports_states[i] != base_auto_imports_states[i])
06930               {
06931                 Use* u = Uses[i];
06932 
06933                 if (u->discarded) continue;
06934 
06935                 Package* p = u->get_package ();
06936                 if (p->is_cmt ()) continue;
06937 
06938                 if (Cmt::get_debug ())
06939                   {
06940                     cout << constituent.name  << " has import " << p->get_name () << endl;
06941                   }
06942 
06943                 if (u->auto_imports != Off) continue;
06944 
06945                 imports.push_back (u);
06946               }
06947           }
06948         
06949         if (imports.size () == 0) continue;
06950 
06951         cmt_string prefix;
06952             
06953         //
06954         // Documents are not considered 
06955         //
06956         switch (constituent.type)
06957           {
06958           case Application:
06959             prefix = "app_";
06960             break;
06961           case Library:
06962             prefix = "lib_";
06963             break;
06964           }
06965             
06966         buffer = "macro_append ";
06967         buffer += prefix;
06968         buffer += constituent.name;
06969         buffer += "_cflags ";
06970         buffer += " \' ";
06971         for (i = 0; i < imports.size (); i++)
06972           {
06973             Use* u = imports[i];
06974             
06975             u->fill_includes_macro (buffer);
06976             u->fill_macro (buffer, "cflags");
06977           }
06978         buffer += "\'";
06979         apply ();
06980         
06981         buffer = "macro_append ";
06982         buffer += prefix;
06983         buffer += constituent.name;
06984         buffer += "_pp_cflags ";
06985         buffer += " \" ";
06986         for (i = 0; i < imports.size (); i++)
06987           {
06988             Use* u = imports[i];
06989             
06990             u->fill_macro (buffer, "pp_cflags");
06991           }
06992         buffer += "\"";
06993         apply ();
06994         
06995         buffer = "macro_append ";
06996         buffer += prefix;
06997         buffer += constituent.name;
06998         buffer += "_cppflags ";
06999         buffer += " \' ";
07000         for (i = 0; i < imports.size (); i++)
07001           {
07002             Use* u = imports[i];
07003             
07004             u->fill_includes_macro (buffer);
07005             u->fill_macro (buffer, "cppflags");
07006           }
07007         buffer += "\'";
07008         apply ();
07009         
07010         buffer = "macro_append ";
07011         buffer += prefix;
07012         buffer += constituent.name;
07013         buffer += "_pp_cppflags ";
07014         buffer += " \" ";
07015         for (i = 0; i < imports.size (); i++)
07016           {
07017             Use* u = imports[i];
07018             
07019             u->fill_macro (buffer, "pp_cppflags");
07020           }
07021         buffer += "\"";
07022         apply ();
07023         
07024         buffer = "macro_append ";
07025         buffer += prefix;
07026         buffer += constituent.name;
07027         buffer += "_fflags ";
07028         buffer += " \' ";
07029         for (i = 0; i < imports.size (); i++)
07030           {
07031             Use* u = imports[i];
07032             
07033             u->fill_includes_macro (buffer);
07034             u->fill_macro (buffer, "fflags");
07035           }
07036         buffer += "\'";
07037         apply ();
07038         
07039         buffer = "macro_append ";
07040         buffer += prefix;
07041         buffer += constituent.name;
07042         buffer += "_pp_fflags ";
07043         buffer += " \" ";
07044         for (i = 0; i < imports.size (); i++)
07045           {
07046             Use* u = imports[i];
07047             
07048             u->fill_macro (buffer, "pp_fflags");
07049           }
07050         buffer += "\"";
07051         apply ();
07052         
07060        buffer = "macro_append ";
07061        buffer += constituent.name;
07062        buffer += "linkopts ";
07063        buffer += " \" ";
07064        for (i = 0; i < imports.size (); i++)
07065          {
07066            Use* u = imports[i];
07067            
07068            u->fill_macro (buffer, "linkopts");
07069          }
07070        buffer += "\"";
07071        apply ();
07072        
07080         buffer = "macro_append ";
07081         buffer += constituent.name;
07082         buffer += "_use_linkopts ";
07083         buffer += " \" ";
07084         
07085         current_use->fill_macro (buffer, "linkopts");
07086         
07087         for (i = 0; i < Uses.size (); i++)
07088           {
07089             if (auto_imports_states[i])
07090               {
07091                 Use* u = Uses[i];
07092                 
07093                 if (u->discarded) continue;
07094                 
07095                 Package* p = u->get_package ();
07096                 if (p->is_cmt ()) continue;
07097 
07098                 u->fill_macro (buffer, "linkopts");
07099               }
07100           }
07101         buffer += "\"";
07102         apply ();
07103 
07104         //==== GLAST addition for vs.net ==========
07105         buffer = "macro ";
07106         buffer += constituent.name;
07107         buffer += "_GUID \"{88BF15AB-5A2D-4bea-B64F-02752C2A1F4F}\" ";
07108         apply ();
07109       }
07110   }

void StandardMacroBuilder::fill_for_branches  )  [inline]
 

srcdir src =/ inc mgrdir mgr =..// bin javabin doc version package

_project _cmtpath _offset package_cmtpath package_offset project

Basic macros (src, mgr, ...)

Definition at line 6278 of file cmt_parser.cxx.

References apply(), buffer, Cmt::configure_current_cmtpath(), current_package, current_style, fs, Symbol::is_selected(), mgr_style, and none_style.

Referenced by Cmt::set_standard_macros().

06279   {
06284     if (current_style == none_style)
06285       {
06286         buffer = "macro srcdir \".";
06287         buffer += "\"";
06288         apply ();
06289 
06290         buffer = "macro src \".";
06291         buffer += fs;
06292         buffer += "\"";
06293         apply ();
06294 
06295         buffer = "macro inc \".";
06296         buffer += fs;
06297         buffer += "\"";
06298         apply ();
06299 
06300         buffer = "macro mgr \".";
06301         buffer += fs;
06302         buffer += "\"";
06303         apply ();
06304 
06305         buffer = "macro bin \".";
06306         buffer += fs;
06307         buffer += "\"";
06308         apply ();
06309 
06310         buffer = "macro javabin \".";
06311         buffer += fs;
06312         buffer += "\"";
06313         apply ();
06314 
06315         buffer = "macro doc \".";
06316         buffer += fs;
06317         buffer += "\"";
06318         apply ();
06319       }
06320     else
06321       {
06322         if (!Symbol::is_selected ("srcdir"))
06323           {
06324             buffer = "macro srcdir \"..";
06325             buffer += fs;
06326             buffer += "src";
06327             buffer += "\"";
06328             apply ();
06329           }
06330         
06331         if (!Symbol::is_selected ("src"))
06332           {
06333             buffer = "macro src \"..";
06334             buffer += fs;
06335             buffer += "src";
06336             buffer += fs;
06337             buffer += "\"";
06338             apply ();
06339           }
06340         
06341         if (!Symbol::is_selected ("inc"))
06342           {
06343             buffer = "macro inc \"..";
06344             buffer += fs;
06345             buffer += "src";
06346             buffer += fs;
06347             buffer += "\"";
06348             apply ();
06349           }
06350         
06351         if (!Symbol::is_selected ("doc"))
06352           {
06353             buffer = "macro doc \"..";
06354             buffer += fs;
06355             buffer += "doc";
06356             buffer += fs;
06357             buffer += "\"";
06358             apply ();
06359           }
06360         
06361         if (!Symbol::is_selected ("bin"))
06362           {
06363             cmt_string package_tag = current_package;
06364             package_tag += "_tag";
06365 
06366             buffer = "macro bin \"..";
06367             buffer += fs;
06368             buffer += "$(";
06369             buffer += package_tag;
06370             buffer += ")";
06371             buffer += fs;
06372             buffer += "\"";
06373             apply ();
06374           }
06375 
06376         if (!Symbol::is_selected ("javabin"))
06377           {
06378             buffer = "macro javabin \"..";
06379             buffer += fs;
06380             buffer += "classes";
06381             buffer += fs;
06382             buffer += "\"";
06383             apply ();
06384           }
06385         
06386         if (current_style == mgr_style)
06387           {
06388             buffer = "macro mgrdir \"mgr\"";
06389             apply ();
06390 
06391             buffer = "macro mgr \"..";
06392             buffer += fs;
06393             buffer += "mgr";
06394             buffer += fs;
06395             buffer += "\"";
06396             apply ();
06397           }
06398         else
06399           {
06400             buffer = "macro mgrdir \"cmt\"";
06401             apply ();
06402 
06403             buffer = "macro mgr \"..";
06404             buffer += fs;
06405             buffer += "cmt";
06406             buffer += fs;
06407             buffer += "\"";
06408             apply ();
06409           }
06410 
06411         Cmt::configure_current_cmtpath ();
06412       }
06413   }

void StandardMacroBuilder::fill_for_CMTVERSION  )  [inline]
 

CMTVERSION.

Definition at line 6172 of file cmt_parser.cxx.

References apply(), buffer, and CMTVERSION.

06173   {
06174     buffer = "macro CMTVERSION \"";
06175     buffer += CMTVERSION;
06176     buffer += "\"";
06177     apply ();
06178   }

void StandardMacroBuilder::fill_for_constituent_macros  )  [inline]
 

Macros implied or required to manage constituents.

Definition at line 7115 of file cmt_parser.cxx.

References Constituent::constituents(), Constituent::ConstituentVector, current_use, Constituent::group, Group::groups(), Group::GroupVector, Symbol::is_selected(), Group::name(), Constituent::name, SyntaxParser::parse_requirements_line(), and cmt_vector< T >::size().

Referenced by Cmt::set_standard_macros().

07116   {
07117     int number;
07118     cmt_string temp;
07119 
07120     const Constituent::ConstituentVector& constituents = Constituent::constituents ();
07121   
07122     if (!Symbol::is_selected ("constituents"))
07123       {
07124         temp = "macro_append constituents \" ";
07125         
07126         for (number = 0; number < constituents.size (); number++)
07127           {
07128             const Constituent& constituent = constituents[number];
07129             
07130             if (constituent.group == 0)
07131               {
07132                 temp += constituent.name;
07133                 temp += " ";
07134               }
07135           }
07136         
07137         temp += "\"";
07138         
07139         SyntaxParser::parse_requirements_line (temp, current_use);
07140       }
07141     
07142     SyntaxParser::parse_requirements_line ("macro_append all_constituents \" $(constituents)\"", 
07143                                            current_use);
07144     
07145     if (!Symbol::is_selected ("constituentsclean"))
07146       {
07147         temp = "macro_append constituentsclean \" ";
07148         
07149         for (number = constituents.size () - 1; number >= 0 ; number--)
07150           {
07151             const Constituent& constituent = constituents[number];
07152             
07153             if (constituent.group == 0)
07154               {
07155                 temp += constituent.name;
07156                 temp += "clean ";
07157               }
07158           }
07159         
07160         temp += "\"";
07161         
07162         SyntaxParser::parse_requirements_line (temp, current_use);
07163       }
07164     
07165     SyntaxParser::parse_requirements_line ("macro_append all_constituentsclean \" $(constituentsclean)\"", 
07166                                            current_use);
07167     
07168     const Group::GroupVector& groups = Group::groups ();
07169     
07170     for (number = 0; number < groups.size (); number++)
07171       {
07172         const Group& group = groups[number];
07173         
07174         temp = "macro_append ";
07175         temp += group.name ();
07176         temp += "_constituents \" ";
07177         
07178         int i;
07179         
07180         for (i = 0; i < constituents.size (); i++)
07181           {
07182             const Constituent& constituent = constituents[i];
07183             
07184             if ((constituent.group != 0) && 
07185                 (group.name () == constituent.group->name ()))
07186               {
07187                 temp += constituent.name;
07188                 temp += " ";
07189               }
07190           }
07191         
07192         temp += "\"";
07193         
07194         SyntaxParser::parse_requirements_line (temp, current_use);
07195         
07196         temp = "macro_append ";
07197         temp += group.name ();
07198         temp += "_constituentsclean \" ";
07199         
07200         for (i = constituents.size () - 1; i >= 0 ; i--)
07201           {
07202             const Constituent& constituent = constituents[i];
07203             
07204             if ((constituent.group != 0) && 
07205                 (group.name () == constituent.group->name ()))
07206               {
07207                 temp += constituent.name;
07208                 temp += "clean ";
07209               }
07210           }
07211         
07212         temp += "\"";
07213         
07214         SyntaxParser::parse_requirements_line (temp, current_use);
07215     }
07216   }

void StandardMacroBuilder::fill_for_current_package const cmt_string current_dir  )  [inline]
 

Macros to be defined once current_package is known and even before reading its requirements file.

Definition at line 7239 of file cmt_parser.cxx.

References fill_for_package(), and fill_for_tag().

Referenced by Cmt::set_standard_macros().

07240   {
07241     fill_for_tag ();
07242     fill_for_package (current_dir);
07243   }

void StandardMacroBuilder::fill_for_fincludes  )  [inline]
 

fincludes

Definition at line 6753 of file cmt_parser.cxx.

References apply(), buffer, Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06754   {
06755     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06756 
06757     if (Uses.size () == 0) return;
06758 
06759     if (!Symbol::is_selected ("fincludes"))
06760       {
06761         buffer = "macro_append fincludes \" $(includes)\"";
06762         apply ();
06763       }
06764   }

void StandardMacroBuilder::fill_for_includes  )  [inline]
 

includes

Definition at line 6710 of file cmt_parser.cxx.

References apply(), buffer, Use::current(), Use::get_ordered_uses(), Use::include_path, Use::includes, Symbol::is_selected(), Include::name, cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06711   {
06712     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06713 
06714     if (Uses.size () == 0) return;
06715 
06716     if (!Symbol::is_selected ("includes"))
06717       {
06718         buffer = "macro_append includes \' ";
06719 
06720         Use& use = Use::current();
06721 
06722         if (use.include_path == "")
06723           {
06724             buffer += "$(ppcmd)\"$(srcdir)\" ";
06725           }
06726         else if (use.include_path != "none")
06727           {
06728             buffer += "$(ppcmd)\"";
06729             buffer += use.include_path;
06730             buffer += "\" ";
06731           }
06732         
06733         for (int include_number = 0;
06734              include_number < use.includes.size ();
06735              include_number++)
06736           {
06737             Include& incl = use.includes[include_number];
06738             
06739             buffer += "$(ppcmd)\"";
06740             buffer += incl.name;
06741             buffer += "\" ";
06742           }
06743         
06744         buffer += "$(use_includes)\'";
06745         
06746         apply ();
06747       }
06748   }

void StandardMacroBuilder::fill_for_install_area  )  [inline]
 

Definitions for installation area mechanisms.

Apply all cmtpath patterns

Definition at line 7221 of file cmt_parser.cxx.

References CmtPathPattern::apply_all(), get_strategy(), CmtInstallAreaMgr::instance(), and CmtInstallAreaMgr::setup().

Referenced by Cmt::set_standard_macros().

07222   {
07223     CmtPathPattern::apply_all ();
07224 
07225     if (get_strategy ("InstallArea"))
07226       {
07227         CmtInstallAreaMgr& ia_mgr = CmtInstallAreaMgr::instance ();
07228 
07229         //cout << "#IA7>" << endl;
07230         
07231         ia_mgr.setup ();
07232       }
07233   }

void StandardMacroBuilder::fill_for_package const cmt_string current_dir  )  [inline]
 

PACKAGE_ROOT.

Definition at line 6235 of file cmt_parser.cxx.

References apply(), buffer, current_package, current_prefix, current_version, and Symbol::is_selected().

Referenced by fill_for_current_package().

06236   {
06237     buffer = "macro package \"";
06238     buffer += current_package;
06239     buffer += "\"";
06240     apply ();
06241 
06242     buffer = "macro version \"";
06243     buffer += current_version;
06244     buffer += "\"";
06245     apply ();
06246 
06247     if (!Symbol::is_selected ("PACKAGE_ROOT"))
06248       {
06249         buffer = "macro PACKAGE_ROOT \"$(";
06250         buffer += current_prefix;
06251         buffer += "ROOT";
06252         buffer += ")\"";
06253 
06254         apply ();
06255       }
06256   }

void StandardMacroBuilder::fill_for_project  )  [inline]
 

project

Definition at line 6418 of file cmt_parser.cxx.

References apply(), buffer, current_style, Project::get_current(), Project::get_name(), and none_style.

Referenced by Cmt::set_standard_macros().

06419   {
06420     if (current_style == none_style) return;
06421 
06422     cmt_string project_name;
06423     Project* project = Project::get_current ();
06424     if (project != 0)
06425       {
06426         project_name = project->get_name ();
06427       }
06428 
06429     buffer = "macro project \"";
06430     buffer += project_name;
06431     buffer += "\"";
06432     apply ();
06433   }

void StandardMacroBuilder::fill_for_tag  )  [inline]
 

tag

Definition at line 6207 of file cmt_parser.cxx.

References apply(), buffer, current_tag, Symbol::is_selected(), and CmtSystem::testenv().

Referenced by fill_for_current_package().

06208   {
06209     static bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
06210 
06211     if (!Symbol::is_selected ("tag"))
06212       {
06213         if (tag_debug) cerr << "set_standard_macro2.1> current_tag=" << current_tag << endl;
06214 
06215         if (current_tag == "")
06216           {
06217             buffer = "macro tag \"$(CMTCONFIG)\"";
06218           }
06219         else
06220           {
06221             buffer = "macro tag \"";
06222             buffer += current_tag;
06223             buffer += "\"";
06224           }
06225         
06226         if (tag_debug) cerr << " define tag: " << buffer << endl;
06227         
06228         apply ();
06229       }
06230   }

void StandardMacroBuilder::fill_for_use_cflags  )  [inline]
 

use_cflags

Definition at line 6567 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06568   {
06569     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06570 
06571     if (Uses.size () == 0) return;
06572 
06573     if (!Symbol::is_selected ("use_cflags"))
06574       {
06575         Use::fill_macro_all (buffer, "cflags");
06576         apply ();
06577       }
06578   }

void StandardMacroBuilder::fill_for_use_cppflags  )  [inline]
 

use_cppflags

Definition at line 6599 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06600   {
06601     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06602 
06603     if (Uses.size () == 0) return;
06604 
06605     if (!Symbol::is_selected ("use_cppflags"))
06606       {
06607         Use::fill_macro_all (buffer, "cppflags");
06608         apply ();
06609       }
06610   }

void StandardMacroBuilder::fill_for_use_fflags  )  [inline]
 

use_fflags

Definition at line 6631 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06632   {
06633     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06634 
06635     if (Uses.size () == 0) return;
06636 
06637     if (!Symbol::is_selected ("use_fflags"))
06638       {
06639         Use::fill_macro_all (buffer, "fflags");
06640         apply ();
06641       }
06642   }

void StandardMacroBuilder::fill_for_use_fincludes  )  [inline]
 

use_fincludes

Definition at line 6519 of file cmt_parser.cxx.

References apply(), buffer, Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06520   {
06521     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06522 
06523     if (Uses.size () == 0) return;
06524 
06525     if (!Symbol::is_selected ("use_fincludes"))
06526       {
06527         buffer = "macro_append use_fincludes \" $(use_includes)\"";
06528         apply ();
06529       }
06530   }

void StandardMacroBuilder::fill_for_use_includes  )  [inline]
 

use_includes

Definition at line 6479 of file cmt_parser.cxx.

References apply(), Use::auto_imports, buffer, Use::discarded, Use::fill_includes_macro(), Cmt::get_debug(), Use::get_ordered_uses(), Use::get_package(), Use::get_package_name(), Package::is_cmt(), Symbol::is_selected(), Off, cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06480   {
06481     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06482 
06483     if (Uses.size () == 0) return;
06484 
06485     if (!Symbol::is_selected ("use_includes"))
06486       {
06487         buffer = "macro_append use_includes \' ";
06488         
06489         for (int number = 0; number < Uses.size (); number++)
06490           {
06491             Use* use = Uses[number];
06492             
06493             if (use->discarded) continue;
06494 
06495             Package* p = use->get_package ();
06496             if (p->is_cmt ()) continue;
06497 
06498             if (Cmt::get_debug ())
06499               {
06500                 cout << "fill use_includes for " << use->get_package_name () 
06501                      << " discarded=" << use->discarded
06502                      << " auto_imports=" << use->auto_imports << endl;
06503               }
06504             
06505             if (use->auto_imports == Off) continue;
06506             
06507             use->fill_includes_macro (buffer);
06508           }
06509         
06510         buffer += "\'";
06511         
06512         apply ();
06513       }
06514   }

void StandardMacroBuilder::fill_for_use_libraries  )  [inline]
 

use_libraries

Definition at line 6679 of file cmt_parser.cxx.

References apply(), buffer, Use::discarded, Use::fill_macro(), Use::get_ordered_uses(), Use::get_package(), Package::is_cmt(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06680   {
06681     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06682 
06683     if (Uses.size () == 0) return;
06684 
06685     if (!Symbol::is_selected ("use_libraries"))
06686       {
06687         buffer  = "macro use_libraries \"";
06688 
06689         for (int number = 0; number < Uses.size (); number++)
06690           {
06691             Use* use = Uses[number];
06692             
06693             if (use->discarded) continue;
06694             
06695             Package* p = use->get_package ();
06696             if (p->is_cmt ()) continue;
06697 
06698             use->fill_macro (buffer, "libraries");
06699           }
06700         
06701         buffer += "\"";
06702         
06703         apply ();
06704       }
06705   }

void StandardMacroBuilder::fill_for_use_linkopts  )  [inline]
 

use_linkopts

Definition at line 6663 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06664   {
06665     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06666 
06667     if (Uses.size () == 0) return;
06668 
06669     if (!Symbol::is_selected ("use_linkopts"))
06670       {
06671         Use::fill_macro_all (buffer, "linkopts");
06672         apply ();
06673       }
06674   }

void StandardMacroBuilder::fill_for_use_pp_cflags  )  [inline]
 

use_pp_cflags

Definition at line 6583 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06584   {
06585     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06586 
06587     if (Uses.size () == 0) return;
06588 
06589     if (!Symbol::is_selected ("use_pp_cflags"))
06590       {
06591         Use::fill_macro_all (buffer, "pp_cflags");
06592         apply ();
06593       }
06594   }

void StandardMacroBuilder::fill_for_use_pp_cppflags  )  [inline]
 

use_pp_cppflags

Definition at line 6615 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06616   {
06617     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06618 
06619     if (Uses.size () == 0) return;
06620 
06621     if (!Symbol::is_selected ("use_pp_cppflags"))
06622       {
06623         Use::fill_macro_all (buffer, "pp_cppflags");
06624         apply ();
06625       }
06626   }

void StandardMacroBuilder::fill_for_use_pp_fflags  )  [inline]
 

use_pp_fflags

Definition at line 6647 of file cmt_parser.cxx.

References apply(), buffer, Use::fill_macro_all(), Use::get_ordered_uses(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06648   {
06649     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06650 
06651     if (Uses.size () == 0) return;
06652 
06653     if (!Symbol::is_selected ("use_pp_fflags"))
06654       {
06655         Use::fill_macro_all (buffer, "pp_fflags");
06656         apply ();
06657       }
06658   }

void StandardMacroBuilder::fill_for_use_requirements  )  [inline]
 

use_requirements

Definition at line 6438 of file cmt_parser.cxx.

References apply(), buffer, Use::discarded, fs, Use::get_ordered_uses(), Symbol::is_selected(), Use::located(), mgr_style, Use::prefix, cmt_vector< T >::size(), Use::style, and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06439   {
06440     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06441 
06442     if (Uses.size () == 0) return;
06443 
06444     if (!Symbol::is_selected ("use_requirements"))
06445       {
06446         buffer  = "macro use_requirements \"";
06447         buffer += "requirements ";
06448         
06449         for (int number = 0; number < Uses.size (); number++)
06450           {
06451             Use* use = Uses[number];
06452             
06453             if (use->discarded) continue;
06454             
06455             if (use->located ())
06456               {
06457                 buffer += "$(";
06458                 buffer += use->prefix;
06459                 buffer += "ROOT)";
06460                 buffer += fs;
06461                 
06462                 if (use->style == mgr_style) buffer += "mgr";
06463                 else buffer += "cmt";
06464                 
06465                 buffer += fs;
06466                 buffer += "requirements ";
06467               }
06468           }
06469         
06470         buffer += "\"";
06471         
06472         apply ();
06473       }
06474   }

void StandardMacroBuilder::fill_for_use_stamps  )  [inline]
 

use_stamps

Definition at line 6535 of file cmt_parser.cxx.

References apply(), buffer, Use::current(), Use::discarded, Use::fill_macro(), Use::get_ordered_uses(), Use::get_package(), Package::is_cmt(), Symbol::is_selected(), cmt_vector< T >::size(), and Use::UsePtrVector.

Referenced by Cmt::set_standard_macros().

06536   {
06537     Use::UsePtrVector& Uses = Use::get_ordered_uses ();
06538 
06539     if (Uses.size () == 0) return;
06540 
06541     if (!Symbol::is_selected ("use_stamps"))
06542       {
06543         buffer = "macro use_stamps \"";
06544         (Use::current()).fill_macro (buffer, "stamps");
06545         
06546         for (int number = 0; number < Uses.size (); number++)
06547           {
06548             Use* use = Uses[number];
06549             
06550             if (use->discarded) continue;
06551 
06552             Package* p = use->get_package ();
06553             if (p->is_cmt ()) continue;
06554             
06555             use->fill_macro (buffer, "stamps");
06556           }
06557         
06558         buffer += "\"";
06559         
06560         apply ();
06561       }
06562   }


Member Data Documentation

cmt_string StandardMacroBuilder::buffer [private]
 

Definition at line 7247 of file cmt_parser.cxx.

Referenced by apply(), fill_for_all_constituents(), fill_for_branches(), fill_for_CMTVERSION(), fill_for_fincludes(), fill_for_includes(), fill_for_package(), fill_for_project(), fill_for_tag(), fill_for_use_cflags(), fill_for_use_cppflags(), fill_for_use_fflags(), fill_for_use_fincludes(), fill_for_use_includes(), fill_for_use_libraries(), fill_for_use_linkopts(), fill_for_use_pp_cflags(), fill_for_use_pp_cppflags(), fill_for_use_pp_fflags(), fill_for_use_requirements(), fill_for_use_stamps(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::current_package [private]
 

Definition at line 7252 of file cmt_parser.cxx.

Referenced by fill_for_branches(), fill_for_package(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::current_prefix [private]
 

Definition at line 7254 of file cmt_parser.cxx.

Referenced by fill_for_package(), and StandardMacroBuilder().

CmtDirStyle StandardMacroBuilder::current_style [private]
 

Definition at line 7255 of file cmt_parser.cxx.

Referenced by fill_for_branches(), fill_for_project(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::current_tag [private]
 

Definition at line 7251 of file cmt_parser.cxx.

Referenced by fill_for_tag(), and StandardMacroBuilder().

Use* StandardMacroBuilder::current_use [private]
 

Definition at line 7250 of file cmt_parser.cxx.

Referenced by apply(), fill_for_all_constituents(), fill_for_constituent_macros(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::current_version [private]
 

Definition at line 7253 of file cmt_parser.cxx.

Referenced by fill_for_package(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::fs [private]
 

Definition at line 7246 of file cmt_parser.cxx.

Referenced by fill_for_branches(), fill_for_use_requirements(), and StandardMacroBuilder().

cmt_string StandardMacroBuilder::pwd [private]
 

Definition at line 7249 of file cmt_parser.cxx.

Referenced by StandardMacroBuilder().

CmtSystem::cmt_string_vector StandardMacroBuilder::vb [private]
 

Definition at line 7248 of file cmt_parser.cxx.

Referenced by StandardMacroBuilder().


The documentation for this class was generated from the following file:
Generated on Mon May 2 10:26:02 2005 for CMT by doxygen 1.3.5