Main Page   Class Hierarchy   Compound List   File List   Compound 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 Methods

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

void fill_for_package_tag ()
 <package>_tag. More...

void fill_for_package (const cmt_string& current_dir)
 <PACKAGE>ROOT PACKAGE_ROOT <package>_root <PACKAGE>VERSION. More...

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

void fill_for_use_tag (Use* use)
 <used_package>_tag. More...

void fill_for_use_ROOT (Use* use)
 <USEDPACKAGE>ROOT. More...

void fill_for_use_root (Use* use)
 <USEDPACKAGE>_root. More...

void fill_for_use_version (Use* use)
 <USEDPACKAGE>VERSION. More...

void fill_for_uses ()
void fill_for_use_requirements ()
 use_requirements. More...

void fill_for_use_includes ()
 use_includes. More...

void fill_for_use_fincludes ()
 use_fincludes. More...

void fill_for_use_stamps ()
 use_stamps. More...

void fill_for_use_cflags ()
 use_cflags. More...

void fill_for_use_pp_cflags ()
 use_pp_cflags. More...

void fill_for_use_cppflags ()
 use_cppflags. More...

void fill_for_use_pp_cppflags ()
 use_pp_cppflags. More...

void fill_for_use_fflags ()
 use_fflags. More...

void fill_for_use_pp_fflags ()
 use_pp_fflags. More...

void fill_for_use_linkopts ()
 use_linkopts. More...

void fill_for_use_libraries ()
 use_libraries. More...

void fill_for_includes ()
 includes. More...

void fill_for_fincludes ()
 fincludes. More...

void fill_for_all_constituents ()
 Macros specific to constituents. More...


Private Attributes

cmt_string fs
 Only for linkopts we take care of the order. More...

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 7909 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 7913 of file cmt_parser.cxx.

07918   {
07919     fs = CmtSystem::file_separator ();
07920     buffer = "";
07921     pwd = CmtSystem::pwd ();
07922     CmtSystem::split (pwd, fs, vb);
07923     current_use = &(Use::current ());
07924     current_tag = tag;
07925     current_package = package;
07926     current_version = version;
07927     current_prefix = prefix;
07928     current_style = style;
07929   }


Member Function Documentation

void StandardMacroBuilder::apply ( ) [inline]
 

Definition at line 7931 of file cmt_parser.cxx.

Referenced by fill_for_all_constituents(), fill_for_branches(), fill_for_fincludes(), fill_for_includes(), fill_for_package(), fill_for_package_tag(), fill_for_tag(), fill_for_use_ROOT(), 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_root(), fill_for_use_stamps(), fill_for_use_tag(), and fill_for_use_version().

07932   {
07933     Cmt::parse_requirements_line (buffer, current_use);
07934     buffer = "";
07935   }

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

Definition at line 8677 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08678   {
08680     Constituent::parse_all ();
08681 
08682     Use::UsePtrVector& Uses = Use::uses ();
08683 
08684     const Constituent::ConstituentVector& constituents =
08685       Constituent::constituents ();
08686 
08687   
08689 
08690     cmt_vector<bool> base_auto_imports_states;
08691 
08692     base_auto_imports_states.resize (Uses.size ());
08693 
08694     int number;
08695 
08696     for (number = 0; number < Uses.size (); number++)
08697       {
08698         Use* use = Uses[number];
08699         base_auto_imports_states[number] = (use->auto_imports != Off);
08700       }
08701 
08703 
08704     for (number = 0; number < constituents.size (); number++)
08705       {
08706         const Constituent& constituent = constituents[number];
08707 
08708         Use::UsePtrVector imports;
08709         int i;
08710 
08728         if (constituent.type == Document) continue;
08729         if (constituent.imports.size () == 0) 
08730           {
08731             buffer = "macro_append ";
08732             buffer += constituent.name;
08733             buffer += "_use_linkopts ";
08734             buffer += " \" ";
08735         
08736             current_use->fill_macro (buffer, "linkopts");
08737         
08738             for (i = 0; i < Uses.size (); i++)
08739               {
08740                 if (base_auto_imports_states[i])
08741                   {
08742                     Use* u = Uses[i];
08743                 
08744                     if (u->package == "CMT") continue;
08745                     if (u->package == "methods") continue;
08746                     if (u->discarded) continue;
08747                     
08748                     u->fill_macro (buffer, "linkopts");
08749                   }
08750               }
08751             buffer += "\"";
08752             apply ();
08753 
08754           /*
08755             buffer = "macro_append ";
08756             buffer += constituent.name;
08757             buffer += "_use_linkopts ";
08758             buffer += " \" $(use_linkopts)\"";
08759             apply ();
08760           */
08761 
08762             continue;
08763           }
08764 
08770         cmt_vector<bool> auto_imports_states (base_auto_imports_states);
08771 
08772         for (i = 0; i < constituent.imports.size (); i++)
08773           {
08774             const cmt_string& import = constituent.imports[i];
08775             
08776             //
08777             // Resolve the imported uses
08778             //
08779 
08780             int use_index = Use::find_index (import, "", "");
08781 
08782             if (use_index >= 0)
08783               {
08784                 Use* u = Uses[use_index];
08785             
08786                 if (u->package == "CMT") continue;
08787                 if (u->package == "methods") continue;
08788                 if (u->discarded) continue;
08789                 if (u->auto_imports != Off) continue;
08790 
08791                 Use::set_auto_imports_state (use_index, auto_imports_states);
08792               }
08793           }
08794 
08799         for (i = 0; i < base_auto_imports_states.size (); i++)
08800           {
08801             if (auto_imports_states[i] != base_auto_imports_states[i])
08802               {
08803                 Use* u = Uses[i];
08804 
08805                 if (u->package == "CMT") continue;
08806                 if (u->package == "methods") continue;
08807                 if (u->discarded) continue;
08808                 if (u->auto_imports != Off) continue;
08809 
08810                 imports.push_back (u);
08811               }
08812           }
08813         
08814         if (imports.size () == 0) return;
08815 
08816         cmt_string prefix;
08817             
08818         //
08819         // Documents are not considered 
08820         //
08821         switch (constituent.type)
08822           {
08823           case Application:
08824             prefix = "app_";
08825             break;
08826           case Library:
08827             prefix = "lib_";
08828             break;
08829           }
08830             
08831         buffer = "macro_append ";
08832         buffer += prefix;
08833         buffer += constituent.name;
08834         buffer += "_cflags ";
08835         buffer += " \' ";
08836         for (i = 0; i < imports.size (); i++)
08837           {
08838             Use* u = imports[i];
08839             
08840             u->fill_includes_macro (buffer);
08841             u->fill_macro (buffer, "cflags");
08842           }
08843         buffer += "\'";
08844         apply ();
08845         
08846         buffer = "macro_append ";
08847         buffer += prefix;
08848         buffer += constituent.name;
08849         buffer += "_pp_cflags ";
08850         buffer += " \" ";
08851         for (i = 0; i < imports.size (); i++)
08852           {
08853             Use* u = imports[i];
08854             
08855             u->fill_macro (buffer, "pp_cflags");
08856           }
08857         buffer += "\"";
08858         apply ();
08859         
08860         buffer = "macro_append ";
08861         buffer += prefix;
08862         buffer += constituent.name;
08863         buffer += "_cppflags ";
08864         buffer += " \' ";
08865         for (i = 0; i < imports.size (); i++)
08866           {
08867             Use* u = imports[i];
08868             
08869             u->fill_includes_macro (buffer);
08870             u->fill_macro (buffer, "cppflags");
08871           }
08872         buffer += "\'";
08873         apply ();
08874         
08875         buffer = "macro_append ";
08876         buffer += prefix;
08877         buffer += constituent.name;
08878         buffer += "_pp_cppflags ";
08879         buffer += " \" ";
08880         for (i = 0; i < imports.size (); i++)
08881           {
08882             Use* u = imports[i];
08883             
08884             u->fill_macro (buffer, "pp_cppflags");
08885           }
08886         buffer += "\"";
08887         apply ();
08888         
08889         buffer = "macro_append ";
08890         buffer += prefix;
08891         buffer += constituent.name;
08892         buffer += "_fflags ";
08893         buffer += " \' ";
08894         for (i = 0; i < imports.size (); i++)
08895           {
08896             Use* u = imports[i];
08897             
08898             u->fill_includes_macro (buffer);
08899             u->fill_macro (buffer, "fflags");
08900           }
08901         buffer += "\'";
08902         apply ();
08903         
08904         buffer = "macro_append ";
08905         buffer += prefix;
08906         buffer += constituent.name;
08907         buffer += "_pp_fflags ";
08908         buffer += " \" ";
08909         for (i = 0; i < imports.size (); i++)
08910           {
08911             Use* u = imports[i];
08912             
08913             u->fill_macro (buffer, "pp_fflags");
08914           }
08915         buffer += "\"";
08916         apply ();
08917 
08925         buffer = "macro_append ";
08926         buffer += constituent.name;
08927         buffer += "linkopts ";
08928         buffer += " \" ";
08929         for (i = 0; i < imports.size (); i++)
08930           {
08931             Use* u = imports[i];
08932             
08933             u->fill_macro (buffer, "linkopts");
08934           }
08935         buffer += "\"";
08936         apply ();
08937         
08944         buffer = "macro_append ";
08945         buffer += constituent.name;
08946         buffer += "_use_linkopts ";
08947         buffer += " \" ";
08948         
08949         current_use->fill_macro (buffer, "linkopts");
08950         
08951         for (i = 0; i < Uses.size (); i++)
08952           {
08953             if (auto_imports_states[i])
08954               {
08955                 Use* u = Uses[i];
08956                 
08957                 if (u->package == "CMT") continue;
08958                 if (u->package == "methods") continue;
08959                 if (u->discarded) continue;
08960                 
08961                 u->fill_macro (buffer, "linkopts");
08962               }
08963           }
08964         buffer += "\"";
08965         apply ();
08966       }
08967   }

void StandardMacroBuilder::fill_for_branches ( ) [inline]
 

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

Definition at line 8086 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08087   {
08092     if (current_style == none_style)
08093       {
08094         buffer = "macro srcdir \".";
08095         buffer += "\"";
08096         apply ();
08097 
08098         buffer = "macro src \".";
08099         buffer += fs;
08100         buffer += "\"";
08101         apply ();
08102 
08103         buffer = "macro inc \".";
08104         buffer += fs;
08105         buffer += "\"";
08106         apply ();
08107 
08108         buffer = "macro mgr \".";
08109         buffer += fs;
08110         buffer += "\"";
08111         apply ();
08112 
08113         buffer = "macro bin \".";
08114         buffer += fs;
08115         buffer += "\"";
08116         apply ();
08117 
08118         buffer = "macro javabin \".";
08119         buffer += fs;
08120         buffer += "\"";
08121         apply ();
08122 
08123         buffer = "macro doc \".";
08124         buffer += fs;
08125         buffer += "\"";
08126         apply ();
08127 
08128         buffer = "macro version \"\"";
08129         apply ();
08130 
08131         buffer = "macro package \"";
08132         buffer += current_package;
08133         buffer += "\"";
08134         apply ();
08135       }
08136     else
08137       {
08138         if (!Symbol::is_selected ("srcdir"))
08139           {
08140             buffer = "macro srcdir \"..";
08141             buffer += fs;
08142             buffer += "src";
08143             buffer += "\"";
08144             apply ();
08145           }
08146         
08147         if (!Symbol::is_selected ("src"))
08148           {
08149             buffer = "macro src \"..";
08150             buffer += fs;
08151             buffer += "src";
08152             buffer += fs;
08153             buffer += "\"";
08154             apply ();
08155           }
08156         
08157         if (!Symbol::is_selected ("inc"))
08158           {
08159             buffer = "macro inc \"..";
08160             buffer += fs;
08161             buffer += "src";
08162             buffer += fs;
08163             buffer += "\"";
08164             apply ();
08165           }
08166         
08167         if (!Symbol::is_selected ("doc"))
08168           {
08169             buffer = "macro doc \"..";
08170             buffer += fs;
08171             buffer += "doc";
08172             buffer += fs;
08173             buffer += "\"";
08174             apply ();
08175           }
08176         
08177         if (!Symbol::is_selected ("bin"))
08178           {
08179             cmt_string package_tag = current_package;
08180             package_tag += "_tag";
08181 
08182             buffer = "macro bin \"..";
08183             buffer += fs;
08184             buffer += "$(";
08185             buffer += package_tag;
08186             buffer += ")";
08187             buffer += fs;
08188             buffer += "\"";
08189             apply ();
08190           }
08191 
08192         if (!Symbol::is_selected ("javabin"))
08193           {
08194             buffer = "macro javabin \"..";
08195             buffer += fs;
08196             buffer += "classes";
08197             buffer += fs;
08198             buffer += "\"";
08199             apply ();
08200           }
08201         
08202         if (current_style == mgr_style)
08203           {
08204             buffer = "macro mgrdir \"mgr\"";
08205             apply ();
08206 
08207             buffer = "macro mgr \"..";
08208             buffer += fs;
08209             buffer += "mgr";
08210             buffer += fs;
08211             buffer += "\"";
08212             apply ();
08213           }
08214         else
08215           {
08216             buffer = "macro mgrdir \"cmt\"";
08217             apply ();
08218 
08219             buffer = "macro mgr \"..";
08220             buffer += fs;
08221             buffer += "cmt";
08222             buffer += fs;
08223             buffer += "\"";
08224             apply ();
08225           }
08226         
08227         buffer = "macro version \"";
08228         buffer += current_version;
08229         buffer += "\"";
08230         apply ();
08231 
08232         buffer = "macro package \"";
08233         buffer += current_package;
08234         buffer += "\"";
08235         apply ();
08236       }
08237   }

void StandardMacroBuilder::fill_for_fincludes ( ) [inline]
 

fincludes.

Definition at line 8658 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08659   {
08660     Use::UsePtrVector& Uses = Use::uses ();
08661 
08662     if (Uses.size () == 0) return;
08663 
08664     if (!Symbol::is_selected ("fincludes"))
08665       {
08666         buffer = "macro_append fincludes \" $(includes)\"";
08667         apply ();
08668       }
08669   }

void StandardMacroBuilder::fill_for_includes ( ) [inline]
 

includes.

Definition at line 8615 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08616   {
08617     Use::UsePtrVector& Uses = Use::uses ();
08618 
08619     if (Uses.size () == 0) return;
08620 
08621     if (!Symbol::is_selected ("includes"))
08622       {
08623         buffer = "macro_append includes \' ";
08624 
08625         Use& use = Use::current();
08626 
08627         if (use.include_path == "")
08628           {
08629             buffer += "$(ppcmd)\"$(srcdir)\" ";
08630           }
08631         else if (use.include_path != "none")
08632           {
08633             buffer += "$(ppcmd)\"";
08634             buffer += use.include_path;
08635             buffer += "\" ";
08636           }
08637         
08638         for (int include_number = 0;
08639              include_number < use.includes.size ();
08640              include_number++)
08641           {
08642             Include& incl = use.includes[include_number];
08643             
08644             buffer += "$(ppcmd)\"";
08645             buffer += incl.name;
08646             buffer += "\" ";
08647           }
08648         
08649         buffer += "$(use_includes)\'";
08650         
08651         apply ();
08652       }
08653   }

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

<PACKAGE>ROOT PACKAGE_ROOT <package>_root <PACKAGE>VERSION.

Definition at line 7989 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

07990   {
07991     cmt_string PACKAGE_ROOT = current_prefix;
07992     PACKAGE_ROOT += "ROOT";
07993     
07994     if (!Symbol::is_selected (PACKAGE_ROOT))
07995       {
07996         if (current_use->path == "")
07997           {
07998             buffer = "macro ";
07999             buffer += PACKAGE_ROOT;
08000             buffer += " \"";
08001             buffer += current_dir;
08002             buffer += "\"";
08003           }
08004         else
08005           {
08006             current_use->path.replace_all (CmtSystem::file_separator (), fs);
08007             
08008             buffer = "macro ";
08009             buffer += PACKAGE_ROOT;
08010             buffer += " \"";
08011             buffer += current_use->path;
08012             buffer += fs;
08013             buffer += current_use->package;
08014             buffer += fs;
08015             buffer += current_use->version;
08016             buffer += "\"";
08017           }
08018         
08019         apply ();
08020       }
08021 
08022     if (!Symbol::is_selected ("PACKAGE_ROOT"))
08023       {
08024         buffer = "macro PACKAGE_ROOT \"$(";
08025         buffer += PACKAGE_ROOT;
08026         buffer += ")\"";
08027 
08028         apply ();
08029       }
08030 
08031     cmt_string package_root = current_use->package;
08032     package_root += "_root";
08033     
08034     if (!Symbol::is_selected (package_root))
08035       {
08036         buffer = "macro ";
08037         buffer += package_root;
08038         buffer += " \"";
08039 
08040         if (current_use->path == "")
08041           {
08042             buffer += current_dir;
08043           }
08044         else
08045           {
08046             current_use->path.replace_all (CmtSystem::file_separator (), fs);
08047 
08048             buffer += get_best_form (vb, current_use->path);
08049             buffer += fs;
08050             buffer += current_use->package;
08051             buffer += fs;
08052             buffer += current_use->version;
08053           }
08054         buffer += "\"";
08055 
08056         apply ();
08057       }
08058 
08059     cmt_string package_version = current_prefix;
08060     package_version += "VERSION";
08061 
08062     if (!Symbol::is_selected (package_version))
08063       {
08064         buffer = "macro ";
08065         buffer += package_version;
08066         buffer += " \"";
08067         buffer += current_use->version;
08068         buffer += "\"";
08069 
08070         apply ();
08071       }
08072   }

void StandardMacroBuilder::fill_for_package_tag ( ) [inline]
 

<package>_tag.

Definition at line 7968 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

07969   {
07970     cmt_string package_tag = current_package;
07971     package_tag += "_tag";
07972     
07973     if (!Symbol::is_selected (package_tag))
07974       {
07975         buffer  = "macro ";
07976         buffer += package_tag;
07977         buffer += " \"$(tag)\"";
07978 
07979         apply ();
07980       }
07981   }

void StandardMacroBuilder::fill_for_tag ( ) [inline]
 

tag.

Definition at line 7940 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

07941   {
07942     static bool tag_debug = CmtSystem::testenv ("TAGDEBUG");
07943 
07944     if (!Symbol::is_selected ("tag"))
07945       {
07946         if (tag_debug) cerr << "set_standard_macro2.1> current_tag=" << current_tag << endl;
07947 
07948         if (current_tag == "")
07949           {
07950             buffer = "macro tag \"$(CMTCONFIG)\"";
07951           }
07952         else
07953           {
07954             buffer = "macro tag \"";
07955             buffer += current_tag;
07956             buffer += "\"";
07957           }
07958         
07959         if (tag_debug) cerr << " define tag: " << buffer << endl;
07960         
07961         apply ();
07962       }
07963   }

void StandardMacroBuilder::fill_for_use_ROOT ( Use * use ) [inline]
 

<USEDPACKAGE>ROOT.

Definition at line 8258 of file cmt_parser.cxx.

Referenced by fill_for_uses().

08259   {
08260     cmt_string PACKAGE_ROOT = use->prefix;
08261     PACKAGE_ROOT += "ROOT";
08262 
08263     if (!Symbol::is_selected (PACKAGE_ROOT))
08264       {
08265         if (use->located ())
08266           {
08267             buffer  = "macro ";
08268             buffer += PACKAGE_ROOT;
08269             buffer += " \"";
08270             buffer += use->get_full_path ();
08271             buffer += "\"";
08272             apply ();
08273           }
08274       }
08275   }

void StandardMacroBuilder::fill_for_use_cflags ( ) [inline]
 

use_cflags.

Definition at line 8473 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08474   {
08475     Use::UsePtrVector& Uses = Use::uses ();
08476 
08477     if (Uses.size () == 0) return;
08478 
08479     if (!Symbol::is_selected ("use_cflags"))
08480       {
08481         Use::fill_macro_all (buffer, "cflags");
08482         apply ();
08483       }
08484   }

void StandardMacroBuilder::fill_for_use_cppflags ( ) [inline]
 

use_cppflags.

Definition at line 8505 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08506   {
08507     Use::UsePtrVector& Uses = Use::uses ();
08508 
08509     if (Uses.size () == 0) return;
08510 
08511     if (!Symbol::is_selected ("use_cppflags"))
08512       {
08513         Use::fill_macro_all (buffer, "cppflags");
08514         apply ();
08515       }
08516   }

void StandardMacroBuilder::fill_for_use_fflags ( ) [inline]
 

use_fflags.

Definition at line 8537 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08538   {
08539     Use::UsePtrVector& Uses = Use::uses ();
08540 
08541     if (Uses.size () == 0) return;
08542 
08543     if (!Symbol::is_selected ("use_fflags"))
08544       {
08545         Use::fill_macro_all (buffer, "fflags");
08546         apply ();
08547       }
08548   }

void StandardMacroBuilder::fill_for_use_fincludes ( ) [inline]
 

use_fincludes.

Definition at line 8426 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08427   {
08428     Use::UsePtrVector& Uses = Use::uses ();
08429 
08430     if (Uses.size () == 0) return;
08431 
08432     if (!Symbol::is_selected ("use_fincludes"))
08433       {
08434         buffer = "macro_append use_fincludes \" $(use_includes)\"";
08435         apply ();
08436       }
08437   }

void StandardMacroBuilder::fill_for_use_includes ( ) [inline]
 

use_includes.

Definition at line 8387 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08388   {
08389     Use::UsePtrVector& Uses = Use::uses ();
08390 
08391     if (Uses.size () == 0) return;
08392 
08393     if (!Symbol::is_selected ("use_includes"))
08394       {
08395         buffer = "macro_append use_includes \' ";
08396         
08397         for (int number = 0; number < Uses.size (); number++)
08398           {
08399             Use* use = Uses[number];
08400             
08401             if (use->package == "CMT") continue;
08402             if (use->package == "methods") continue;
08403             
08404             if (Cmt::get_debug ())
08405               {
08406                 cout << "fill use_includes for " << use->package 
08407                      << " discarded=" << use->discarded
08408                      << " auto_imports=" << use->auto_imports << endl;
08409               }
08410             
08411             if (use->discarded) continue;
08412             if (use->auto_imports == Off) continue;
08413             
08414             use->fill_includes_macro (buffer);
08415           }
08416         
08417         buffer += "\'";
08418         
08419         apply ();
08420       }
08421   }

void StandardMacroBuilder::fill_for_use_libraries ( ) [inline]
 

use_libraries.

Definition at line 8585 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08586   {
08587     Use::UsePtrVector& Uses = Use::uses ();
08588 
08589     if (Uses.size () == 0) return;
08590 
08591     if (!Symbol::is_selected ("use_libraries"))
08592       {
08593         buffer  = "macro use_libraries \"";
08594 
08595         for (int number = 0; number < Uses.size (); number++)
08596           {
08597             Use* use = Uses[number];
08598             
08599             if (use->package == "CMT") continue;
08600             if (use->package == "methods") continue;
08601             if (use->discarded) continue;
08602             
08603             use->fill_macro (buffer, "libraries");
08604           }
08605         
08606         buffer += "\"";
08607         
08608         apply ();
08609       }
08610   }

void StandardMacroBuilder::fill_for_use_linkopts ( ) [inline]
 

use_linkopts.

Definition at line 8569 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08570   {
08571     Use::UsePtrVector& Uses = Use::uses ();
08572 
08573     if (Uses.size () == 0) return;
08574 
08575     if (!Symbol::is_selected ("use_linkopts"))
08576       {
08577         Use::fill_macro_all (buffer, "linkopts");
08578         apply ();
08579       }
08580   }

void StandardMacroBuilder::fill_for_use_pp_cflags ( ) [inline]
 

use_pp_cflags.

Definition at line 8489 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08490   {
08491     Use::UsePtrVector& Uses = Use::uses ();
08492 
08493     if (Uses.size () == 0) return;
08494 
08495     if (!Symbol::is_selected ("use_pp_cflags"))
08496       {
08497         Use::fill_macro_all (buffer, "pp_cflags");
08498         apply ();
08499       }
08500   }

void StandardMacroBuilder::fill_for_use_pp_cppflags ( ) [inline]
 

use_pp_cppflags.

Definition at line 8521 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08522   {
08523     Use::UsePtrVector& Uses = Use::uses ();
08524 
08525     if (Uses.size () == 0) return;
08526 
08527     if (!Symbol::is_selected ("use_pp_cppflags"))
08528       {
08529         Use::fill_macro_all (buffer, "pp_cppflags");
08530         apply ();
08531       }
08532   }

void StandardMacroBuilder::fill_for_use_pp_fflags ( ) [inline]
 

use_pp_fflags.

Definition at line 8553 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08554   {
08555     Use::UsePtrVector& Uses = Use::uses ();
08556 
08557     if (Uses.size () == 0) return;
08558 
08559     if (!Symbol::is_selected ("use_pp_fflags"))
08560       {
08561         Use::fill_macro_all (buffer, "pp_fflags");
08562         apply ();
08563       }
08564   }

void StandardMacroBuilder::fill_for_use_requirements ( ) [inline]
 

use_requirements.

Definition at line 8346 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08347   {
08348     Use::UsePtrVector& Uses = Use::uses ();
08349 
08350     if (Uses.size () == 0) return;
08351 
08352     if (!Symbol::is_selected ("use_requirements"))
08353       {
08354         buffer  = "macro use_requirements \"";
08355         buffer += "requirements ";
08356         
08357         for (int number = 0; number < Uses.size (); number++)
08358           {
08359             Use* use = Uses[number];
08360             
08361             if (use->discarded) continue;
08362             
08363             if (use->located ())
08364               {
08365                 buffer += "$(";
08366                 buffer += use->prefix;
08367                 buffer += "ROOT)";
08368                 buffer += fs;
08369                 
08370                 if (use->style == mgr_style) buffer += "mgr";
08371                 else buffer += "cmt";
08372                 
08373                 buffer += fs;
08374                 buffer += "requirements ";
08375               }
08376           }
08377         
08378         buffer += "\"";
08379         
08380         apply ();
08381       }
08382   }

void StandardMacroBuilder::fill_for_use_root ( Use * use ) [inline]
 

<USEDPACKAGE>_root.

Definition at line 8280 of file cmt_parser.cxx.

Referenced by fill_for_uses().

08281   {
08282     cmt_string package_root = use->package;
08283     package_root += "_root";
08284 
08285     if (!Symbol::is_selected (package_root))
08286       {
08287         if (use->located ())
08288           {
08289             buffer  = "macro ";
08290             buffer += package_root;
08291             buffer += " \"";
08292             buffer += get_best_form (vb, use->real_path);
08293             buffer += fs;
08294             buffer += use->package;
08295             buffer += fs;
08296             buffer += use->version;
08297             buffer += "\"";
08298             apply ();
08299           }
08300       }
08301   }

void StandardMacroBuilder::fill_for_use_stamps ( ) [inline]
 

use_stamps.

Definition at line 8442 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08443   {
08444     Use::UsePtrVector& Uses = Use::uses ();
08445 
08446     if (Uses.size () == 0) return;
08447 
08448     if (!Symbol::is_selected ("use_stamps"))
08449       {
08450         buffer = "macro use_stamps \"";
08451         (Use::current()).fill_macro (buffer, "stamps");
08452         
08453         for (int number = 0; number < Uses.size (); number++)
08454           {
08455             Use* use = Uses[number];
08456             
08457             if (use->package == "CMT") continue;
08458             if (use->package == "methods") continue;
08459             if (use->discarded) continue;
08460             
08461             use->fill_macro (buffer, "stamps");
08462           }
08463         
08464         buffer += "\"";
08465         
08466         apply ();
08467       }
08468   }

void StandardMacroBuilder::fill_for_use_tag ( Use * use ) [inline]
 

<used_package>_tag.

Definition at line 8242 of file cmt_parser.cxx.

Referenced by fill_for_uses().

08243   {
08244     cmt_string package_tag = use->package + "_tag";
08245 
08246     if (!Symbol::is_selected (package_tag))
08247       {
08248         buffer  = "macro ";
08249         buffer += package_tag;
08250         buffer += " \"$(tag)\"";
08251         apply ();
08252       }
08253   }

void StandardMacroBuilder::fill_for_use_version ( Use * use ) [inline]
 

<USEDPACKAGE>VERSION.

Definition at line 8306 of file cmt_parser.cxx.

Referenced by fill_for_uses().

08307   {
08308     cmt_string package_version = use->prefix;
08309     package_version += "VERSION";
08310     
08311     if (!Symbol::is_selected (package_version))
08312       {
08313         buffer  = "macro ";
08314         buffer += package_version;
08315         buffer += " \"";
08316         buffer += use->version;
08317         buffer += "\"";
08318         apply ();
08319       }
08320   }

void StandardMacroBuilder::fill_for_uses ( ) [inline]
 

Definition at line 8322 of file cmt_parser.cxx.

Referenced by Cmt::set_standard_macros().

08323   {
08324     Use::UsePtrVector& Uses = Use::uses ();
08325 
08326     if (Uses.size () == 0) return;
08327 
08328     for (int number = 0; number < Uses.size (); number++)
08329       {
08330         Use* use = Uses[number];
08331 
08332         if (use->package == "CMT") continue;
08333         if (use->package == "methods") continue;
08334         if (use->discarded) continue;
08335 
08336         fill_for_use_tag (use);
08337         fill_for_use_ROOT (use);
08338         fill_for_use_root (use);
08339         fill_for_use_version (use);
08340       }
08341   }


Member Data Documentation

cmt_string StandardMacroBuilder::buffer [private]
 

Definition at line 8971 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::current_package [private]
 

Definition at line 8976 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::current_prefix [private]
 

Definition at line 8978 of file cmt_parser.cxx.

CmtDirStyle StandardMacroBuilder::current_style [private]
 

Definition at line 8979 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::current_tag [private]
 

Definition at line 8975 of file cmt_parser.cxx.

Use * StandardMacroBuilder::current_use [private]
 

Definition at line 8974 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::current_version [private]
 

Definition at line 8977 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::fs [private]
 

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)

Definition at line 8970 of file cmt_parser.cxx.

cmt_string StandardMacroBuilder::pwd [private]
 

Definition at line 8973 of file cmt_parser.cxx.

CmtSystem::cmt_string_vector StandardMacroBuilder::vb [private]
 

Definition at line 8972 of file cmt_parser.cxx.


The documentation for this class was generated from the following file:
Generated at Mon Jun 10 17:58:54 2002 for CMT by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000