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:

[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
Use* | current_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:

- cmt_parser.cxx