[2] | 1 | //----------------------------------------------------------- |
---|
| 2 | // Copyright Christian Arnault LAL-Orsay CNRS |
---|
| 3 | // arnault@lal.in2p3.fr |
---|
| 4 | // See the complete license in cmt_license.txt "http://www.cecill.info". |
---|
| 5 | //----------------------------------------------------------- |
---|
| 6 | |
---|
| 7 | #include <stdio.h> |
---|
| 8 | #include <stdlib.h> |
---|
| 9 | #include <string.h> |
---|
| 10 | #include <ctype.h> |
---|
| 11 | |
---|
| 12 | #include "cmt_language.h" |
---|
| 13 | #include "cmt_system.h" |
---|
| 14 | #include "cmt_database.h" |
---|
[528] | 15 | #include "cmt_error.h" |
---|
[2] | 16 | |
---|
| 17 | /*----------------------------------------------------------*/ |
---|
| 18 | /* */ |
---|
| 19 | /* Operations on Language */ |
---|
| 20 | /* */ |
---|
| 21 | /*----------------------------------------------------------*/ |
---|
| 22 | |
---|
| 23 | /*----------------------------------------------------------*/ |
---|
| 24 | void Language::show (const cmt_string& name) |
---|
[400] | 25 | /*----------------------------------------------------------*/ |
---|
[2] | 26 | { |
---|
| 27 | Language& language = find (name); |
---|
| 28 | |
---|
[528] | 29 | if (language == null ()) |
---|
| 30 | { |
---|
| 31 | cmt_string t (name); |
---|
[2] | 32 | |
---|
[528] | 33 | CmtError::set (CmtError::language_not_found, t); |
---|
| 34 | } |
---|
| 35 | else |
---|
| 36 | { |
---|
| 37 | language.show (); |
---|
| 38 | } |
---|
[2] | 39 | } |
---|
| 40 | |
---|
| 41 | /*----------------------------------------------------------*/ |
---|
| 42 | void Language::show_all () |
---|
[400] | 43 | /*----------------------------------------------------------*/ |
---|
[2] | 44 | { |
---|
| 45 | static LanguageVector& Languages = languages (); |
---|
| 46 | |
---|
| 47 | int number; |
---|
| 48 | |
---|
| 49 | for (number = 0; number < Languages.size (); number++) |
---|
| 50 | { |
---|
| 51 | Language& language = Languages[number]; |
---|
| 52 | |
---|
| 53 | language.show (); |
---|
| 54 | } |
---|
| 55 | } |
---|
| 56 | |
---|
| 57 | /*----------------------------------------------------------*/ |
---|
| 58 | void Language::show_names () |
---|
[400] | 59 | /*----------------------------------------------------------*/ |
---|
[2] | 60 | { |
---|
| 61 | static LanguageVector& Languages = languages (); |
---|
| 62 | |
---|
| 63 | int number; |
---|
| 64 | |
---|
| 65 | for (number = 0; number < Languages.size (); number++) |
---|
| 66 | { |
---|
| 67 | Language& language = Languages[number]; |
---|
| 68 | cout << language.m_name << endl; |
---|
| 69 | } |
---|
| 70 | } |
---|
| 71 | |
---|
| 72 | /*----------------------------------------------------------*/ |
---|
| 73 | void Language::setup_all_fragments () |
---|
[400] | 74 | /*----------------------------------------------------------*/ |
---|
[2] | 75 | { |
---|
| 76 | static LanguageVector& Languages = languages (); |
---|
| 77 | |
---|
| 78 | int language_index; |
---|
| 79 | |
---|
| 80 | if (Languages.size () == 0) return; |
---|
| 81 | |
---|
| 82 | for (language_index = 0; |
---|
| 83 | language_index < Languages.size (); |
---|
| 84 | language_index++) |
---|
| 85 | { |
---|
| 86 | Language& language = Languages[language_index]; |
---|
| 87 | |
---|
| 88 | language.setup_fragments (); |
---|
| 89 | } |
---|
| 90 | } |
---|
| 91 | |
---|
| 92 | /*----------------------------------------------------------*/ |
---|
| 93 | Language& Language::find (const cmt_string& name) |
---|
[400] | 94 | /*----------------------------------------------------------*/ |
---|
[2] | 95 | { |
---|
| 96 | static LanguageVector& Languages = languages (); |
---|
| 97 | |
---|
| 98 | int language_index; |
---|
| 99 | |
---|
| 100 | if (Languages.size () == 0) return (null ()); |
---|
| 101 | |
---|
| 102 | for (language_index = 0; |
---|
| 103 | language_index < Languages.size (); |
---|
| 104 | language_index++) |
---|
| 105 | { |
---|
| 106 | Language& language = Languages[language_index]; |
---|
| 107 | |
---|
| 108 | if (language.m_name == name) |
---|
| 109 | { |
---|
| 110 | return (language); |
---|
| 111 | } |
---|
| 112 | } |
---|
| 113 | |
---|
| 114 | return (null ()); |
---|
| 115 | } |
---|
| 116 | |
---|
| 117 | /*----------------------------------------------------------*/ |
---|
| 118 | Language& Language::find_with_suffix (const cmt_string& suffix) |
---|
[400] | 119 | /*----------------------------------------------------------*/ |
---|
[2] | 120 | { |
---|
| 121 | static LanguageVector& Languages = languages (); |
---|
| 122 | |
---|
| 123 | int language_index; |
---|
| 124 | |
---|
| 125 | if (Languages.size () == 0) return (null ()); |
---|
| 126 | |
---|
| 127 | for (language_index = 0; |
---|
| 128 | language_index < Languages.size (); |
---|
| 129 | language_index++) |
---|
| 130 | { |
---|
| 131 | Language& language = Languages[language_index]; |
---|
| 132 | |
---|
| 133 | for (int suffix_index = 0; |
---|
| 134 | suffix_index < language.suffixes.size (); |
---|
| 135 | suffix_index++) |
---|
| 136 | { |
---|
| 137 | cmt_string& s = language.suffixes[suffix_index]; |
---|
| 138 | |
---|
| 139 | if (s == suffix) return (language); |
---|
| 140 | } |
---|
| 141 | } |
---|
| 142 | |
---|
| 143 | return (null ()); |
---|
| 144 | } |
---|
| 145 | |
---|
| 146 | /*----------------------------------------------------------*/ |
---|
[561] | 147 | void Language::action (const CmtSystem::cmt_string_vector& words, |
---|
| 148 | Use* use) |
---|
| 149 | //void Language::action (const CmtSystem::cmt_string_vector& words) |
---|
[400] | 150 | /*----------------------------------------------------------*/ |
---|
[2] | 151 | { |
---|
| 152 | cmt_string name; |
---|
| 153 | |
---|
| 154 | int i = 1; |
---|
| 155 | |
---|
| 156 | name = words[i]; |
---|
| 157 | if (name == "") return; |
---|
| 158 | i++; |
---|
| 159 | |
---|
| 160 | Language& language = add (name); |
---|
| 161 | |
---|
| 162 | for (;i < words.size (); i++) |
---|
| 163 | { |
---|
| 164 | cmt_string& w = words[i]; |
---|
| 165 | if (w == "") break; |
---|
| 166 | |
---|
| 167 | if (w.substr (0, 8) == "-suffix=") |
---|
| 168 | { |
---|
| 169 | cmt_string& suffix = language.suffixes.add (); |
---|
| 170 | |
---|
| 171 | suffix.erase (0); |
---|
| 172 | w.substr (8, suffix); |
---|
| 173 | } |
---|
| 174 | else if (w.substr (0, 8) == "-linker=") |
---|
| 175 | { |
---|
| 176 | w.substr (8, language.linker); |
---|
| 177 | } |
---|
| 178 | else if (w.substr (0, 11) == "-prototypes") |
---|
| 179 | { |
---|
| 180 | language.prototypes = true; |
---|
| 181 | } |
---|
| 182 | else if (w.substr (0, 22) == "-preprocessor_command=") |
---|
| 183 | { |
---|
| 184 | w.substr (22, language.preprocessor_command); |
---|
| 185 | } |
---|
| 186 | else if (w.substr (0, 10) == "-fragment=") |
---|
| 187 | { |
---|
| 188 | w.substr (10, language.fragment_name); |
---|
| 189 | } |
---|
| 190 | else if (w.substr (0, 15) == "-output_suffix=") |
---|
| 191 | { |
---|
| 192 | w.substr (15, language.output_suffix); |
---|
| 193 | } |
---|
| 194 | else if (w.substr (0, 21) == "-extra_output_suffix=") |
---|
| 195 | { |
---|
| 196 | cmt_string& suffix = language.extra_output_suffixes.add (); |
---|
| 197 | |
---|
| 198 | suffix.erase (0); |
---|
| 199 | w.substr (21, suffix); |
---|
| 200 | } |
---|
[483] | 201 | else if (w.substr (0, 22) == "-dependencies_options=") |
---|
| 202 | { |
---|
[486] | 203 | w.substr (22, language.m_dependencies_options); |
---|
[483] | 204 | } |
---|
[2] | 205 | } |
---|
[561] | 206 | language.m_use = use; |
---|
[2] | 207 | } |
---|
| 208 | |
---|
| 209 | /*----------------------------------------------------------*/ |
---|
| 210 | Language& Language::add (const cmt_string& name) |
---|
[400] | 211 | /*----------------------------------------------------------*/ |
---|
[2] | 212 | { |
---|
| 213 | static LanguageVector& Languages = languages (); |
---|
| 214 | |
---|
| 215 | if (name == "") return (null ()); |
---|
| 216 | |
---|
| 217 | { |
---|
| 218 | Language& language = find (name); |
---|
| 219 | if (language != null ()) return (language); |
---|
| 220 | } |
---|
| 221 | |
---|
| 222 | Language& language = Languages.add (); |
---|
| 223 | |
---|
| 224 | language.clear (); |
---|
| 225 | language.m_name = name; |
---|
| 226 | language.fragment_name = name; |
---|
| 227 | |
---|
| 228 | return (language); |
---|
| 229 | } |
---|
| 230 | |
---|
| 231 | |
---|
| 232 | /*----------------------------------------------------------*/ |
---|
| 233 | void Language::clear_all () |
---|
[400] | 234 | /*----------------------------------------------------------*/ |
---|
[2] | 235 | { |
---|
| 236 | static LanguageVector& Languages = languages (); |
---|
| 237 | |
---|
| 238 | for (int i = 0; i < Languages.size (); i++) |
---|
| 239 | { |
---|
| 240 | Language& c = Languages[i]; |
---|
| 241 | c.clear (); |
---|
| 242 | } |
---|
| 243 | Languages.clear (); |
---|
| 244 | } |
---|
| 245 | |
---|
| 246 | /*----------------------------------------------------------*/ |
---|
| 247 | Language::LanguageVector& Language::languages () |
---|
[400] | 248 | /*----------------------------------------------------------*/ |
---|
[2] | 249 | { |
---|
| 250 | static Database& db = Database::instance (); |
---|
| 251 | static LanguageVector& Languages = db.languages (); |
---|
| 252 | |
---|
| 253 | return (Languages); |
---|
| 254 | } |
---|
| 255 | |
---|
| 256 | /*----------------------------------------------------------*/ |
---|
| 257 | Language& Language::null () |
---|
[400] | 258 | /*----------------------------------------------------------*/ |
---|
[2] | 259 | { |
---|
| 260 | static Language null_instance; |
---|
| 261 | |
---|
| 262 | return (null_instance); |
---|
| 263 | } |
---|
| 264 | |
---|
| 265 | /*----------------------------------------------------------*/ |
---|
| 266 | Language::Language () |
---|
[400] | 267 | /*----------------------------------------------------------*/ |
---|
[2] | 268 | { |
---|
| 269 | clear (); |
---|
| 270 | } |
---|
| 271 | |
---|
| 272 | /*----------------------------------------------------------*/ |
---|
| 273 | Language::~Language () |
---|
[400] | 274 | /*----------------------------------------------------------*/ |
---|
[2] | 275 | { |
---|
| 276 | } |
---|
| 277 | |
---|
| 278 | /*----------------------------------------------------------*/ |
---|
| 279 | void Language::clear () |
---|
[400] | 280 | /*----------------------------------------------------------*/ |
---|
[2] | 281 | { |
---|
| 282 | m_name = ""; |
---|
| 283 | linker = "none"; |
---|
| 284 | prototypes = false; |
---|
| 285 | preprocessor_command = "-I"; |
---|
| 286 | fragment_name = ""; |
---|
| 287 | output_suffix = ""; |
---|
| 288 | suffixes.clear (); |
---|
| 289 | extra_output_suffixes.clear (); |
---|
[486] | 290 | m_native_dependencies = false; |
---|
| 291 | m_dependencies_options = "none"; |
---|
[561] | 292 | m_dependencies_options_expanded = ""; |
---|
[486] | 293 | m_native_dependencies_set = false; |
---|
[561] | 294 | m_use = 0; |
---|
[2] | 295 | } |
---|
| 296 | |
---|
| 297 | /*----------------------------------------------------------*/ |
---|
[561] | 298 | void Language::show (PrintMode mode, ostream& out) |
---|
| 299 | //void Language::show () |
---|
[400] | 300 | /*----------------------------------------------------------*/ |
---|
[2] | 301 | { |
---|
[561] | 302 | out << "language " << m_name; |
---|
[2] | 303 | |
---|
| 304 | int i; |
---|
| 305 | |
---|
| 306 | for (i = 0; i < (suffixes.size ()); i++) |
---|
| 307 | { |
---|
| 308 | cmt_string& suffix = suffixes[i]; |
---|
| 309 | |
---|
[561] | 310 | out << " -suffix=" << suffix; |
---|
[2] | 311 | } |
---|
| 312 | |
---|
[561] | 313 | if (linker != "none") |
---|
| 314 | // if (linker != "") |
---|
[2] | 315 | { |
---|
[561] | 316 | switch (mode) |
---|
| 317 | { |
---|
| 318 | case Requirements : |
---|
| 319 | out << " -linker=" << CmtSystem::quote (linker, " \t"); |
---|
| 320 | break; |
---|
| 321 | default: |
---|
| 322 | out << " -linker=" << linker; |
---|
| 323 | break; |
---|
| 324 | } |
---|
[2] | 325 | } |
---|
| 326 | |
---|
| 327 | if (prototypes) |
---|
| 328 | { |
---|
[561] | 329 | out << " -prototypes"; |
---|
[2] | 330 | } |
---|
| 331 | |
---|
| 332 | if (preprocessor_command != "-I") |
---|
| 333 | { |
---|
[561] | 334 | out << " -preprocessor_command="; |
---|
| 335 | switch (mode) |
---|
| 336 | { |
---|
| 337 | case Requirements : |
---|
| 338 | out << CmtSystem::quote (preprocessor_command, " \t"); |
---|
| 339 | break; |
---|
| 340 | default: |
---|
| 341 | out << preprocessor_command; |
---|
| 342 | break; |
---|
| 343 | } |
---|
[2] | 344 | } |
---|
| 345 | |
---|
| 346 | if (fragment_name != m_name) |
---|
| 347 | { |
---|
[561] | 348 | out << " -fragment=" << fragment_name; |
---|
[2] | 349 | } |
---|
| 350 | |
---|
| 351 | if (output_suffix != "") |
---|
| 352 | { |
---|
[561] | 353 | out << " -output_suffix=" << output_suffix; |
---|
[2] | 354 | } |
---|
| 355 | |
---|
| 356 | for (i = 0; i < extra_output_suffixes.size (); i++) |
---|
| 357 | { |
---|
| 358 | cmt_string& suffix = extra_output_suffixes[i]; |
---|
| 359 | |
---|
[561] | 360 | out << " -extra_output_suffix=" << suffix; |
---|
[2] | 361 | } |
---|
| 362 | |
---|
[486] | 363 | if (m_dependencies_options != "none") |
---|
[483] | 364 | { |
---|
[561] | 365 | out << " -dependencies_options="; |
---|
| 366 | switch (mode) |
---|
| 367 | { |
---|
| 368 | case Requirements : |
---|
| 369 | out << CmtSystem::quote (dependencies_options_expanded (), " \t"); |
---|
| 370 | break; |
---|
| 371 | default: |
---|
| 372 | out << m_dependencies_options; |
---|
| 373 | break; |
---|
| 374 | } |
---|
[483] | 375 | } |
---|
| 376 | |
---|
[561] | 377 | out << endl; |
---|
[2] | 378 | } |
---|
| 379 | |
---|
| 380 | /*----------------------------------------------------------*/ |
---|
| 381 | void Language::setup_fragments () |
---|
[400] | 382 | /*----------------------------------------------------------*/ |
---|
[2] | 383 | { |
---|
| 384 | cmt_string n = fragment_name; |
---|
| 385 | |
---|
| 386 | application.set (n); |
---|
| 387 | |
---|
| 388 | n += "_library"; |
---|
| 389 | |
---|
| 390 | library.set (n); |
---|
| 391 | } |
---|
| 392 | |
---|
| 393 | /*----------------------------------------------------------*/ |
---|
| 394 | bool Language::operator == (const cmt_string& name) const |
---|
[400] | 395 | /*----------------------------------------------------------*/ |
---|
[2] | 396 | { |
---|
| 397 | if (m_name == name) return (true); |
---|
| 398 | return (false); |
---|
| 399 | } |
---|
| 400 | |
---|
| 401 | /*----------------------------------------------------------*/ |
---|
| 402 | bool Language::operator == (const Language& other) const |
---|
[400] | 403 | /*----------------------------------------------------------*/ |
---|
[2] | 404 | { |
---|
| 405 | if (this == &other) return (true); |
---|
| 406 | return (false); |
---|
| 407 | } |
---|
| 408 | |
---|
| 409 | /*----------------------------------------------------------*/ |
---|
| 410 | bool Language::operator != (const Language& other) const |
---|
[400] | 411 | /*----------------------------------------------------------*/ |
---|
[2] | 412 | { |
---|
| 413 | if (this != &other) return (true); |
---|
| 414 | return (false); |
---|
| 415 | } |
---|
[483] | 416 | |
---|
| 417 | /*----------------------------------------------------------*/ |
---|
[486] | 418 | bool Language::native_dependencies () |
---|
| 419 | /*----------------------------------------------------------*/ |
---|
| 420 | { |
---|
| 421 | setup_native_dependencies (); |
---|
| 422 | return m_native_dependencies; |
---|
| 423 | } |
---|
| 424 | |
---|
| 425 | /*----------------------------------------------------------*/ |
---|
| 426 | const cmt_string& Language::dependencies_options () const |
---|
| 427 | /*----------------------------------------------------------*/ |
---|
| 428 | { |
---|
| 429 | static cmt_string null_string; |
---|
| 430 | |
---|
| 431 | return m_dependencies_options == "none" ? null_string : m_dependencies_options; |
---|
| 432 | } |
---|
| 433 | |
---|
| 434 | /*----------------------------------------------------------*/ |
---|
[483] | 435 | void Language::setup_native_dependencies () |
---|
| 436 | /*----------------------------------------------------------*/ |
---|
| 437 | { |
---|
[486] | 438 | if (m_native_dependencies_set) return; |
---|
| 439 | m_native_dependencies_set = true; |
---|
| 440 | |
---|
| 441 | if (m_dependencies_options != "none") |
---|
[483] | 442 | { |
---|
[486] | 443 | cmt_string opts (m_dependencies_options); |
---|
[483] | 444 | Symbol::expand (opts); |
---|
| 445 | if (opts != "") |
---|
| 446 | { |
---|
[486] | 447 | m_native_dependencies = true; |
---|
[483] | 448 | } |
---|
[486] | 449 | else |
---|
| 450 | { |
---|
| 451 | m_native_dependencies = false; |
---|
| 452 | } |
---|
[561] | 453 | m_dependencies_options_expanded = opts; |
---|
[483] | 454 | } |
---|
[486] | 455 | else |
---|
| 456 | { |
---|
| 457 | m_native_dependencies = false; |
---|
| 458 | } |
---|
| 459 | |
---|
| 460 | return; |
---|
[483] | 461 | } |
---|
[561] | 462 | |
---|
| 463 | /*----------------------------------------------------------*/ |
---|
| 464 | const cmt_string& Language::dependencies_options_expanded () |
---|
| 465 | /*----------------------------------------------------------*/ |
---|
| 466 | { |
---|
| 467 | setup_native_dependencies (); |
---|
| 468 | return m_dependencies_options_expanded; |
---|
| 469 | } |
---|