#include #include #include #include #include "cmt_use.h"#include "cmt_symbol.h"#include "cmt_system.h"#include "cmt_database.h"Include dependency graph for cmt_symbol.cxx:
Go to the source code of this file.
Classes |
|
| class ? | ActionBuilder |
| class ? | MacroBuilder |
| class ? | PathBuilder |
| class ? | ScriptBuilder |
| class ? | SetBuilder |
| class ? | symbol_marker |
Functions |
|
| void? | resolve_value (cmt_string &text, const cmt_string &symbol_name, const cmt_string &value) |
| ? | Attempt to substitute all occurrences of. |
| void? | resolve_value (cmt_string &text) |
| ? | Attempt to substitute into the specified text all occurrences of. |
| void? | resolve_value_for_macros (cmt_string &text) |
| ? | Attempt to substitute all occurrences of. |
| void? | suppress_OS_delimiters (cmt_string &text) |
| ? | This function suppress all OS delimiters ie ${ } or and replaces them by the pure macro delimiters $( ). |
| bool? | find_path_entry (const cmt_string &paths, const cmt_string &value) |
|
||||||||||||
| ? |
Definition at line 1938 of file cmt_symbol.cxx. References CmtSystem::cd(), CmtSystem::cmt_string_vector, CmtSystem::compress_path(), CmtSystem::path_separator(), CmtSystem::pwd(), cmt_vector< T >::size(), and CmtSystem::split(). Referenced by PathBuilder::build(). 01939 {
01940 static const cmt_string path_separator = CmtSystem::path_separator ();
01941
01942 cmt_string here = CmtSystem::pwd ();
01943 cmt_string rvalue = value;
01944
01945 if (CmtSystem::cd (value))
01946 {
01947 rvalue = CmtSystem::pwd ();
01948 }
01949 else
01950 {
01951 CmtSystem::compress_path (rvalue);
01952 }
01953
01954 CmtSystem::cmt_string_vector items;
01955 CmtSystem::split (paths, path_separator, items);
01956
01957 bool found = false;
01958
01959 for (int i = 0; i < items.size (); i++)
01960 {
01961 const cmt_string& item = items[i];
01962 cmt_string ritem = item;
01963 if (CmtSystem::cd (item))
01964 {
01965 ritem = CmtSystem::pwd ();
01966 }
01967 else
01968 {
01969 CmtSystem::compress_path (ritem);
01970 }
01971
01972 if (ritem == rvalue)
01973 {
01974 found = true;
01975 break;
01976 }
01977 }
01978
01979 CmtSystem::cd (here);
01980 return (found);
01981 }
|
|
| ? |
Attempt to substitute into the specified text all occurrences of. ${xxx} `xxx` xxx% [on Windows only] by the appropriate value: for `xxx` : xxx is considered as a shell command. Value is the result of its execution for other patterns: if xxx is a symbol name, its value is substituted to the pattern otherwise, xxx is tried as an environment variable ===> In all cases, the pattern is filtered away. Definition at line 247 of file cmt_symbol.cxx. References Symbol::all_set(), cmt_string::erase(), CmtSystem::execute(), Symbol::find(), cmt_string::find(), Cmt::get_debug(), symbol_marker::get_lowest(), CmtSystem::getenv(), symbol_marker::intro, symbol_marker::pattern, symbol_marker::ptr, cmt_string::replace_all(), Symbol::resolve_macro_value(), symbol_marker::set(), and cmt_string::substr(). Referenced by PathBuilder::build(), SetBuilder::build(), PathBuilder::clean(), Symbol::expand(), Symbol::resolve_macro_value(), resolve_value_for_macros(), and suppress_OS_delimiters(). 00248 {
00249 //static cmt_regexp reg ("[$%`]");
00250
00251 //if (!reg.match (text)) return;
00252
00253 cmt_string pattern;
00254 cmt_string symbol_name;
00255 char end_pattern;
00256
00257 int start = 0;
00258
00259 for (;;)
00260 {
00261 int begin;
00262 int end;
00263
00264 symbol_marker markers[4];
00265 int num = 0;
00266
00267 markers[num].set (text.find (start, "$("), ')', 2); num++;
00268 markers[num].set (text.find (start, "${"), '}', 2); num++;
00269 markers[num].set (text.find (start, "`"), '`', 1); num++;
00270
00271 #ifdef WIN32
00272 markers[num].set (text.find (start, "%"), '%', 1); num++;
00273 #endif
00274
00275 // Find the first matching pattern
00276
00277 symbol_marker& marker = symbol_marker::get_lowest (markers, num);
00278
00279 begin = marker.ptr;
00280
00281 if (begin == cmt_string::npos) break;
00282
00283 end_pattern = marker.pattern;
00284 start = begin + marker.intro;
00285
00286 end = text.find (start, end_pattern);
00287 if (end == cmt_string::npos)
00288 {
00289 // The pattern is a fake one (no ending!)
00290 start++;
00291 continue;
00292 }
00293
00294 // This should never happen...
00295 if (end < begin) break;
00296
00297 // Extract the complete pattern
00298 text.substr (begin, end - begin + 1, pattern);
00299
00300 // Then only the symbol name
00301 text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
00302
00303 if (text[begin] == '`')
00304 {
00305 cmt_string command = symbol_name;
00306 resolve_value (command);
00307
00308 // The value is a shell command that first needs
00309 // to be applied. The output of the command is then substituted
00310
00311 cmt_string result;
00312
00313 Symbol::all_set ();
00314 CmtSystem::execute (command, result);
00315
00316 int pos;
00317 pos = result.find ('\n');
00318 if (pos != cmt_string::npos) result.erase (pos);
00319 pos = result.find ('\r');
00320 if (pos != cmt_string::npos) result.erase (pos);
00321
00322 if (Cmt::get_debug ())
00323 {
00324 cout << " Executing [" << command << "] to expand a symbol value =>["
00325 << result << "]" << endl;
00326 }
00327
00328 text.replace_all (pattern, result);
00329
00330 // The substitution will restart from the same place
00331 // allowing for recursive replacements
00332 start = begin;
00333 }
00334 else
00335 {
00336 Symbol* symbol = Symbol::find (symbol_name);
00337 if (symbol != 0)
00338 {
00339 // Symbol found
00340 cmt_string value = symbol->resolve_macro_value ();
00341 text.replace_all (pattern, value);
00342
00343 // The substitution will restart from the same place
00344 // allowing for recursive replacements
00345 start = begin;
00346 }
00347 else
00348 {
00349 // Symbol not found. Look for env. variable
00350 cmt_string value = CmtSystem::getenv (symbol_name);
00351
00352 // When the env. variable is not defined, the replacement is empty
00353 // thus all $(xxx) ${xxx} %xxx% patterns are always filtered away.
00354 text.replace_all (pattern, value);
00355
00356 // The substitution will restart from the same place
00357 // allowing for recursive replacements
00358 start = begin;
00359 }
00360 }
00361 }
00362 }
|
|
||||||||||||||||
| ? |
Attempt to substitute all occurrences of. ${} $() [on Windows only] by the specified value in the given text. This is for one symbol only Definition at line 195 of file cmt_symbol.cxx. References cmt_string::replace_all(). 00198 {
00199 static cmt_string pattern;
00200
00201 pattern = "${";
00202 pattern += symbol_name;
00203 pattern += "}";
00204
00205 text.replace_all (pattern, value);
00206
00207 pattern = "$(";
00208 pattern += symbol_name;
00209 pattern += ")";
00210
00211 text.replace_all (pattern, value);
00212
00213 #ifdef WIN32
00214 pattern = "%";
00215 pattern += symbol_name;
00216 pattern += "%";
00217
00218 text.replace_all (pattern, value);
00219 #endif
00220 }
|
|
| ? |
Attempt to substitute all occurrences of. ${xxx} `xxx` xxx% [on Windows only] by the appropriate value: for `xxx` : xxx is considered as a shell command. Value is the result of its execution for other patterns: if xxx is a macro name, its value is substituted to the pattern if xxx is a set or a path, it is kept in place (after fixing the pattern according to the OS style) otherwise it is simply kept in place Definition at line 389 of file cmt_symbol.cxx. References Symbol::all_set(), cmt_string::erase(), CmtSystem::ev_close(), CmtSystem::ev_open(), CmtSystem::execute(), Symbol::find(), cmt_string::find(), Cmt::get_debug(), symbol_marker::get_lowest(), symbol_marker::intro, symbol_marker::pattern, symbol_marker::ptr, cmt_string::replace(), cmt_string::replace_all(), Symbol::resolve_macro_value(), resolve_value(), symbol_marker::set(), cmt_string::substr(), and Symbol::type. Referenced by PathBuilder::build(), SetBuilder::build(), and PathBuilder::clean(). 00390 {
00391 cmt_string pattern;
00392 cmt_string symbol_name;
00393 char end_pattern;
00394
00395 int start = 0;
00396
00397 for (;;)
00398 {
00399 //
00400 // Try and substitute all ${xxx} $(xxx) or %xxx% patterns
00401 // using symbol values, only when the symbol is a macro.
00402 //
00403
00404 int begin;
00405 int end;
00406
00407 symbol_marker markers[4];
00408 int num = 0;
00409
00410 markers[num].set (text.find (start, "$("), ')', 2); num++;
00411 markers[num].set (text.find (start, "${"), '}', 2); num++;
00412
00413 #ifdef WIN32
00414 markers[num].set (text.find (start, "%"), '%', 1); num++;
00415 #endif
00416
00417 markers[num].set (text.find (start, "`"), '`', 1); num++;
00418
00419 // Find the first of three patterns
00420
00421 symbol_marker& marker = symbol_marker::get_lowest (markers, num);
00422
00423 begin = marker.ptr;
00424
00425 if (begin == cmt_string::npos) break;
00426
00427 end_pattern = marker.pattern;
00428 start = begin + marker.intro;
00429
00430 end = text.find (start, end_pattern);
00431 if (end == cmt_string::npos)
00432 {
00433 // The pattern is a fake one (no ending!)
00434 start++;
00435 continue;
00436 }
00437
00438 // This should never happen...
00439 if (end < begin) break;
00440
00441 // Extract the complete pattern
00442 text.substr (begin, end - begin + 1, pattern);
00443
00444 // Then only the macro name
00445 text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
00446
00447 if (text[begin] == '`')
00448 {
00449 cmt_string command = symbol_name;
00450 resolve_value (command);
00451
00452 // The macro value is a shell command that first needs
00453 // to be applied. The output of the command is substituted
00454
00455 cmt_string result;
00456
00457 Symbol::all_set ();
00458 CmtSystem::execute (command, result);
00459
00460 int pos;
00461 pos = result.find ('\n');
00462 if (pos != cmt_string::npos) result.erase (pos);
00463 pos = result.find ('\r');
00464 if (pos != cmt_string::npos) result.erase (pos);
00465
00466 if (Cmt::get_debug ())
00467 {
00468 cout << " Executing [" << command << "] to expand a macro value =>["
00469 << result << "]" << endl;
00470 }
00471
00472 text.replace_all (pattern, result);
00473
00474 // The substitution will restart from the same place
00475 // allowing for recursive replacements
00476 start = begin;
00477 }
00478 else
00479 {
00480 Symbol* macro = Symbol::find (symbol_name);
00481 if ((macro != 0) &&
00482 (macro->type == Symbol::SymbolMacro))
00483 {
00484 // Macro found
00485 cmt_string value = macro->resolve_macro_value ();
00486 text.replace_all (pattern, value);
00487
00488 // The substitution will restart from the same place
00489 // allowing for recursive replacements
00490 start = begin;
00491 }
00492 else if ((macro == 0) ||
00493 ((macro->type == Symbol::SymbolSet) || (macro->type == Symbol::SymbolPath)))
00494 {
00495 // Set found
00496 // ensure that the delimiters will match the OS dependent
00497 // delimiters.
00498
00499 cmt_string pattern_close = marker.pattern;
00500
00501 if (pattern_close != CmtSystem::ev_close ())
00502 {
00503 cmt_string new_pattern;
00504
00505 new_pattern = CmtSystem::ev_open ();
00506 new_pattern += symbol_name;
00507 new_pattern += CmtSystem::ev_close ();
00508
00509 text.replace (pattern, new_pattern);
00510 }
00511
00512 start = end + 1;
00513 }
00514 else
00515 {
00516 start = end + 1;
00517 }
00518 }
00519 }
00520 }
|
|
| ? |
This function suppress all OS delimiters ie ${ } or and replaces them by the pure macro delimiters $( ). `xxx` pattern is replaced by the result of the execution of the command Definition at line 530 of file cmt_symbol.cxx. References Symbol::all_set(), cmt_string::erase(), CmtSystem::execute(), cmt_string::find(), Cmt::get_debug(), symbol_marker::get_lowest(), symbol_marker::intro, symbol_marker::pattern, symbol_marker::ptr, cmt_string::replace(), cmt_string::replace_all(), resolve_value(), symbol_marker::set(), and cmt_string::substr(). Referenced by Symbol::show_macro(). 00531 {
00532 cmt_string pattern;
00533 cmt_string symbol_name;
00534 char end_pattern;
00535
00536 int start = 0;
00537
00538 for (;;)
00539 {
00540 int begin;
00541 int end;
00542
00543 symbol_marker markers[3];
00544 int num = 0;
00545
00546 markers[num].set (text.find (start, "${"), '}', 2); num++;
00547 markers[num].set (text.find (start, "`"), '`', 1); num++;
00548
00549 #ifdef WIN32
00550 markers[num].set (text.find (start, "%"), '%', 1); num++;
00551 #endif
00552
00553 // Find the first of three patterns
00554
00555 symbol_marker& marker = symbol_marker::get_lowest (markers, num);
00556
00557 begin = marker.ptr;
00558
00559 if (begin == cmt_string::npos) break;
00560
00561 end_pattern = marker.pattern;
00562 start = begin + marker.intro;
00563
00564 end = text.find (start, end_pattern);
00565 if (end == cmt_string::npos)
00566 {
00567 // The pattern is a fake one (no ending!)
00568 start++;
00569 continue;
00570 }
00571
00572 // This should never happen...
00573 if (end < begin) break;
00574
00575 // Extract the complete pattern
00576 text.substr (begin, end - begin + 1, pattern);
00577
00578 // Then only the macro name
00579 text.substr (begin + marker.intro, end - begin - marker.intro, symbol_name);
00580
00581 if (text[begin] == '`')
00582 {
00583 cmt_string command = symbol_name;
00584 resolve_value (command);
00585
00586 // The macro value is a shell command that first needs
00587 // to be applied. The output of the command is substituted
00588
00589 cmt_string result;
00590
00591 Symbol::all_set ();
00592 CmtSystem::execute (command, result);
00593
00594 int pos;
00595 pos = result.find ('\n');
00596 if (pos != cmt_string::npos) result.erase (pos);
00597 pos = result.find ('\r');
00598 if (pos != cmt_string::npos) result.erase (pos);
00599
00600 if (Cmt::get_debug ())
00601 {
00602 cout << " Executing [" << command << "] to expand a macro value =>["
00603 << result << "]" << endl;
00604 }
00605
00606 text.replace_all (pattern, result);
00607
00608 // The substitution will restart from the same place
00609 // allowing for recursive replacements
00610 start = begin;
00611 }
00612 else
00613 {
00614 cmt_string new_pattern;
00615
00616 new_pattern = "$(";
00617 new_pattern += symbol_name;
00618 new_pattern += ")";
00619
00620 text.replace (pattern, new_pattern);
00621
00622 start = begin;
00623 }
00624 }
00625 }
|