ROSE  0.10.7.0
stringify.C
1 #include <boost/algorithm/string/predicate.hpp>
2 #include <boost/lexical_cast.hpp>
3 #include <string>
4 #include <vector>
5 
6 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
7 // /src/roseSupport/callbacks.h line 14
8 namespace stringify { namespace Rose { namespace Callbacks {
9  const char* Direction(int64_t i) {
10  switch (i) {
11  case 0L: return "FORWARD";
12  case 1L: return "BACKWARD";
13  default: return "";
14  }
15  }
16 
17  std::string Direction(int64_t i, const std::string &strip) {
18  std::string s = Direction(i);
19  if (s.empty())
20  s = "(Rose::Callbacks::Direction)" + boost::lexical_cast<std::string>(i);
21  if (boost::starts_with(s, strip))
22  s = s.substr(strip.size());
23  return s;
24  }
25 
26  const std::vector<int64_t>& Direction() {
27  static const int64_t values[] = {
28  0L,
29  1L
30  };
31  static const std::vector<int64_t> retval(values, values + 2);
32  return retval;
33  }
34 
35 }}}
36 
37 namespace Rose {
38  std::string stringifyCallbacksDirection(int64_t i, const char *strip, bool canonic) {
39  std::string retval = stringify::Rose::Callbacks::Direction(i);
40  if (retval.empty()) {
41  retval = "(Rose::Callbacks::Direction)" + boost::lexical_cast<std::string>(i);
42  } else {
43  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
44  retval = retval.substr(strlen(strip));
45  if (canonic)
46  retval = "Rose::Callbacks::Direction::" + retval;
47  }
48  return retval;
49  }
50 
51  const std::vector<int64_t>& stringifyCallbacksDirection() {
53  }
54 }
55 
56 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
57 // /src/roseSupport/utility_functions.C line 1027
58 namespace stringify {
59  const char* language_enum(int64_t i) {
60  switch (i) {
61  case 0L: return "e_none";
62  case 1L: return "e_c";
63  case 2L: return "e_cxx";
64  case 3L: return "e_fortran";
65  case 4L: return "e_last_language";
66  default: return "";
67  }
68  }
69 
70  std::string language_enum(int64_t i, const std::string &strip) {
71  std::string s = language_enum(i);
72  if (s.empty())
73  s = "(language_enum)" + boost::lexical_cast<std::string>(i);
74  if (boost::starts_with(s, strip))
75  s = s.substr(strip.size());
76  return s;
77  }
78 
79  const std::vector<int64_t>& language_enum() {
80  static const int64_t values[] = {
81  0L,
82  1L,
83  2L,
84  3L,
85  4L
86  };
87  static const std::vector<int64_t> retval(values, values + 5);
88  return retval;
89  }
90 
91 }
92 
93 namespace Rose {
94  std::string stringify_language_enum(int64_t i, const char *strip, bool canonic) {
95  std::string retval = stringify::language_enum(i);
96  if (retval.empty()) {
97  retval = "(language_enum)" + boost::lexical_cast<std::string>(i);
98  } else {
99  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
100  retval = retval.substr(strlen(strip));
101  if (canonic)
102  retval = "language_enum::" + retval;
103  }
104  return retval;
105  }
106 
107  const std::vector<int64_t>& stringify_language_enum() {
108  return stringify::language_enum();
109  }
110 }
111 
112 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
113 // /src/roseSupport/CommandLine.C line 19
114 namespace stringify { namespace Rose { namespace CommandLine { namespace FailedAssertionBehaviorAdjuster {
115  const char* Behavior(int64_t i) {
116  switch (i) {
117  case 0L: return "ABORT_ON_FAILURE";
118  case 1L: return "EXIT_ON_FAILURE";
119  case 2L: return "THROW_ON_FAILURE";
120  default: return "";
121  }
122  }
123 
124  std::string Behavior(int64_t i, const std::string &strip) {
125  std::string s = Behavior(i);
126  if (s.empty())
127  s = "(Rose::CommandLine::FailedAssertionBehaviorAdjuster::Behavior)" + boost::lexical_cast<std::string>(i);
128  if (boost::starts_with(s, strip))
129  s = s.substr(strip.size());
130  return s;
131  }
132 
133  const std::vector<int64_t>& Behavior() {
134  static const int64_t values[] = {
135  0L,
136  1L,
137  2L
138  };
139  static const std::vector<int64_t> retval(values, values + 3);
140  return retval;
141  }
142 
143 }}}}
144 
145 namespace Rose {
146  std::string stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior(int64_t i, const char *strip, bool canonic) {
148  if (retval.empty()) {
149  retval = "(Rose::CommandLine::FailedAssertionBehaviorAdjuster::Behavior)" + boost::lexical_cast<std::string>(i);
150  } else {
151  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
152  retval = retval.substr(strlen(strip));
153  if (canonic)
154  retval = "Rose::CommandLine::FailedAssertionBehaviorAdjuster::Behavior::" + retval;
155  }
156  return retval;
157  }
158 
159  const std::vector<int64_t>& stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior() {
161  }
162 }
163 
164 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
165 // /src/roseSupport/transformationSupport.h line 37
166 namespace stringify { namespace TransformationSupport {
167  const char* operatorCodeType(int64_t i) {
168  switch (i) {
169  case 0L: return "FUNCTION_CALL_OPERATOR_CODE";
170  case 1L: return "ADD_OPERATOR_CODE";
171  case 2L: return "SUBT_OPERATOR_CODE";
172  case 3L: return "MULT_OPERATOR_CODE";
173  case 4L: return "DIV_OPERATOR_CODE";
174  case 5L: return "INTEGER_DIV_OPERATOR_CODE";
175  case 6L: return "MOD_OPERATOR_CODE";
176  case 7L: return "AND_OPERATOR_CODE";
177  case 8L: return "OR_OPERATOR_CODE";
178  case 9L: return "BITXOR_OPERATOR_CODE";
179  case 10L: return "BITAND_OPERATOR_CODE";
180  case 11L: return "BITOR_OPERATOR_CODE";
181  case 12L: return "EQ_OPERATOR_CODE";
182  case 13L: return "LT_OPERATOR_CODE";
183  case 14L: return "GT_OPERATOR_CODE";
184  case 15L: return "NE_OPERATOR_CODE";
185  case 16L: return "LE_OPERATOR_CODE";
186  case 17L: return "GE_OPERATOR_CODE";
187  case 18L: return "ASSIGN_OPERATOR_CODE";
188  case 19L: return "PLUS_ASSIGN_OPERATOR_CODE";
189  case 20L: return "MINUS_ASSIGN_OPERATOR_CODE";
190  case 21L: return "AND_ASSIGN_OPERATOR_CODE";
191  case 22L: return "IOR_ASSIGN_OPERATOR_CODE";
192  case 23L: return "MULT_ASSIGN_OPERATOR_CODE";
193  case 24L: return "DIV_ASSIGN_OPERATOR_CODE";
194  case 25L: return "MOD_ASSIGN_OPERATOR_CODE";
195  case 26L: return "XOR_ASSIGN_OPERATOR_CODE";
196  case 27L: return "PARENTHESIS_OPERATOR_CODE";
197  case 28L: return "BRACKET_OPERATOR_CODE";
198  case 29L: return "NOT_OPERATOR_CODE";
199  case 30L: return "DEREFERENCE_OPERATOR_CODE";
200  case 31L: return "ADDRESS_OPERATOR_CODE";
201  case 32L: return "LSHIFT_OPERATOR_CODE";
202  case 33L: return "RSHIFT_OPERATOR_CODE";
203  case 34L: return "LSHIFT_ASSIGN_OPERATOR_CODE";
204  case 35L: return "RSHIFT_ASSIGN_OPERATOR_CODE";
205  case 36L: return "PREFIX_PLUSPLUS_OPERATOR_CODE";
206  case 37L: return "POSTFIX_PLUSPLUS_OPERATOR_CODE";
207  case 38L: return "PREFIX_MINUSMINUS_OPERATOR_CODE";
208  case 39L: return "POSTFIX_MINUSMINUS_OPERATOR_CODE";
209  case 99L: return "OPERATOR_CODE_LAST_TAG";
210  default: return "";
211  }
212  }
213 
214  std::string operatorCodeType(int64_t i, const std::string &strip) {
215  std::string s = operatorCodeType(i);
216  if (s.empty())
217  s = "(TransformationSupport::operatorCodeType)" + boost::lexical_cast<std::string>(i);
218  if (boost::starts_with(s, strip))
219  s = s.substr(strip.size());
220  return s;
221  }
222 
223  const std::vector<int64_t>& operatorCodeType() {
224  static const int64_t values[] = {
225  0L,
226  1L,
227  2L,
228  3L,
229  4L,
230  5L,
231  6L,
232  7L,
233  8L,
234  9L,
235  10L,
236  11L,
237  12L,
238  13L,
239  14L,
240  15L,
241  16L,
242  17L,
243  18L,
244  19L,
245  20L,
246  21L,
247  22L,
248  23L,
249  24L,
250  25L,
251  26L,
252  27L,
253  28L,
254  29L,
255  30L,
256  31L,
257  32L,
258  33L,
259  34L,
260  35L,
261  36L,
262  37L,
263  38L,
264  39L,
265  99L
266  };
267  static const std::vector<int64_t> retval(values, values + 41);
268  return retval;
269  }
270 
271 }}
272 
273 namespace Rose {
274  std::string stringifyTransformationSupport_operatorCodeType(int64_t i, const char *strip, bool canonic) {
276  if (retval.empty()) {
277  retval = "(TransformationSupport::operatorCodeType)" + boost::lexical_cast<std::string>(i);
278  } else {
279  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
280  retval = retval.substr(strlen(strip));
281  if (canonic)
282  retval = "TransformationSupport::operatorCodeType::" + retval;
283  }
284  return retval;
285  }
286 
287  const std::vector<int64_t>& stringifyTransformationSupport_operatorCodeType() {
289  }
290 }
291 
292 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
293 // /src/roseSupport/SqlDatabase.h line 121
294 namespace stringify { namespace SqlDatabase {
295  const char* Driver(int64_t i) {
296  switch (i) {
297  case 0L: return "NO_DRIVER";
298  case 1L: return "SQLITE3";
299  case 2L: return "POSTGRESQL";
300  default: return "";
301  }
302  }
303 
304  std::string Driver(int64_t i, const std::string &strip) {
305  std::string s = Driver(i);
306  if (s.empty())
307  s = "(SqlDatabase::Driver)" + boost::lexical_cast<std::string>(i);
308  if (boost::starts_with(s, strip))
309  s = s.substr(strip.size());
310  return s;
311  }
312 
313  const std::vector<int64_t>& Driver() {
314  static const int64_t values[] = {
315  0L,
316  1L,
317  2L
318  };
319  static const std::vector<int64_t> retval(values, values + 3);
320  return retval;
321  }
322 
323 }}
324 
325 namespace Rose {
326  std::string stringifySqlDatabaseDriver(int64_t i, const char *strip, bool canonic) {
327  std::string retval = stringify::SqlDatabase::Driver(i);
328  if (retval.empty()) {
329  retval = "(SqlDatabase::Driver)" + boost::lexical_cast<std::string>(i);
330  } else {
331  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
332  retval = retval.substr(strlen(strip));
333  if (canonic)
334  retval = "SqlDatabase::Driver::" + retval;
335  }
336  return retval;
337  }
338 
339  const std::vector<int64_t>& stringifySqlDatabaseDriver() {
341  }
342 }
343 
344 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
345 // /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 531
346 namespace stringify { namespace Unparse_ExprStmt {
347  const char* token_sequence_position_enum_type(int64_t i) {
348  switch (i) {
349  case 0L: return "e_leading_whitespace_start";
350  case 1L: return "e_leading_whitespace_end";
351  case 2L: return "e_token_subsequence_start";
352  case 3L: return "e_token_subsequence_end";
353  case 4L: return "e_trailing_whitespace_start";
354  case 5L: return "e_trailing_whitespace_end";
355  default: return "";
356  }
357  }
358 
359  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
360  std::string s = token_sequence_position_enum_type(i);
361  if (s.empty())
362  s = "(Unparse_ExprStmt::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
363  if (boost::starts_with(s, strip))
364  s = s.substr(strip.size());
365  return s;
366  }
367 
368  const std::vector<int64_t>& token_sequence_position_enum_type() {
369  static const int64_t values[] = {
370  0L,
371  1L,
372  2L,
373  3L,
374  4L,
375  5L
376  };
377  static const std::vector<int64_t> retval(values, values + 6);
378  return retval;
379  }
380 
381 }}
382 
383 namespace Rose {
384  std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
386  if (retval.empty()) {
387  retval = "(Unparse_ExprStmt::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
388  } else {
389  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
390  retval = retval.substr(strlen(strip));
391  if (canonic)
392  retval = "Unparse_ExprStmt::token_sequence_position_enum_type::" + retval;
393  }
394  return retval;
395  }
396 
397  const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type() {
399  }
400 }
401 
402 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
403 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 19
404 namespace stringify {
405  const char* AssociativitySpecifier(int64_t i) {
406  switch (i) {
407  case 0L: return "e_assoc_none";
408  case 1L: return "e_assoc_right";
409  case 2L: return "e_assoc_left";
410  case 3L: return "e_assoc_last";
411  default: return "";
412  }
413  }
414 
415  std::string AssociativitySpecifier(int64_t i, const std::string &strip) {
416  std::string s = AssociativitySpecifier(i);
417  if (s.empty())
418  s = "(AssociativitySpecifier)" + boost::lexical_cast<std::string>(i);
419  if (boost::starts_with(s, strip))
420  s = s.substr(strip.size());
421  return s;
422  }
423 
424  const std::vector<int64_t>& AssociativitySpecifier() {
425  static const int64_t values[] = {
426  0L,
427  1L,
428  2L,
429  3L
430  };
431  static const std::vector<int64_t> retval(values, values + 4);
432  return retval;
433  }
434 
435 }
436 
437 namespace Rose {
438  std::string stringifyAssociativitySpecifier(int64_t i, const char *strip, bool canonic) {
439  std::string retval = stringify::AssociativitySpecifier(i);
440  if (retval.empty()) {
441  retval = "(AssociativitySpecifier)" + boost::lexical_cast<std::string>(i);
442  } else {
443  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
444  retval = retval.substr(strlen(strip));
445  if (canonic)
446  retval = "AssociativitySpecifier::" + retval;
447  }
448  return retval;
449  }
450 
451  const std::vector<int64_t>& stringifyAssociativitySpecifier() {
453  }
454 }
455 
456 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
457 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 46
458 namespace stringify { namespace UnparseLanguageIndependentConstructs {
459  const char* token_sequence_position_enum_type(int64_t i) {
460  switch (i) {
461  case 0L: return "e_leading_whitespace_start";
462  case 1L: return "e_leading_whitespace_end";
463  case 2L: return "e_token_subsequence_start";
464  case 3L: return "e_token_subsequence_end";
465  case 4L: return "e_trailing_whitespace_start";
466  case 5L: return "e_trailing_whitespace_end";
467  case 6L: return "e_else_whitespace_start";
468  case 7L: return "e_else_whitespace_end";
469  default: return "";
470  }
471  }
472 
473  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
474  std::string s = token_sequence_position_enum_type(i);
475  if (s.empty())
476  s = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
477  if (boost::starts_with(s, strip))
478  s = s.substr(strip.size());
479  return s;
480  }
481 
482  const std::vector<int64_t>& token_sequence_position_enum_type() {
483  static const int64_t values[] = {
484  0L,
485  1L,
486  2L,
487  3L,
488  4L,
489  5L,
490  6L,
491  7L
492  };
493  static const std::vector<int64_t> retval(values, values + 8);
494  return retval;
495  }
496 
497 }}
498 
499 namespace Rose {
500  std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
502  if (retval.empty()) {
503  retval = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
504  } else {
505  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
506  retval = retval.substr(strlen(strip));
507  if (canonic)
508  retval = "UnparseLanguageIndependentConstructs::token_sequence_position_enum_type::" + retval;
509  }
510  return retval;
511  }
512 
513  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type() {
515  }
516 }
517 
518 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
519 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 74
520 namespace stringify { namespace UnparseLanguageIndependentConstructs {
521  const char* unparsed_as_enum_type(int64_t i) {
522  switch (i) {
523  case 0L: return "e_unparsed_as_error";
524  case 1L: return "e_unparsed_as_AST";
525  case 2L: return "e_unparsed_as_partial_token_sequence";
526  case 3L: return "e_unparsed_as_token_stream";
527  case 4L: return "e_unparsed_as_last";
528  default: return "";
529  }
530  }
531 
532  std::string unparsed_as_enum_type(int64_t i, const std::string &strip) {
533  std::string s = unparsed_as_enum_type(i);
534  if (s.empty())
535  s = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_type)" + boost::lexical_cast<std::string>(i);
536  if (boost::starts_with(s, strip))
537  s = s.substr(strip.size());
538  return s;
539  }
540 
541  const std::vector<int64_t>& unparsed_as_enum_type() {
542  static const int64_t values[] = {
543  0L,
544  1L,
545  2L,
546  3L,
547  4L
548  };
549  static const std::vector<int64_t> retval(values, values + 5);
550  return retval;
551  }
552 
553 }}
554 
555 namespace Rose {
556  std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t i, const char *strip, bool canonic) {
558  if (retval.empty()) {
559  retval = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_type)" + boost::lexical_cast<std::string>(i);
560  } else {
561  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
562  retval = retval.substr(strlen(strip));
563  if (canonic)
564  retval = "UnparseLanguageIndependentConstructs::unparsed_as_enum_type::" + retval;
565  }
566  return retval;
567  }
568 
569  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type() {
571  }
572 }
573 
574 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
575 // /src/backend/unparser/formatSupport/unparse_format.h line 51
576 namespace stringify {
577  const char* Format_Opt(int64_t i) {
578  switch (i) {
579  case 0L: return "FORMAT_BEFORE_DIRECTIVE";
580  case 1L: return "FORMAT_AFTER_DIRECTIVE";
581  case 2L: return "FORMAT_BEFORE_STMT";
582  case 3L: return "FORMAT_AFTER_STMT";
583  case 4L: return "FORMAT_BEFORE_BASIC_BLOCK1";
584  case 5L: return "FORMAT_AFTER_BASIC_BLOCK1";
585  case 6L: return "FORMAT_BEFORE_BASIC_BLOCK2";
586  case 7L: return "FORMAT_AFTER_BASIC_BLOCK2";
587  case 8L: return "FORMAT_BEFORE_NESTED_STATEMENT";
588  case 9L: return "FORMAT_AFTER_NESTED_STATEMENT";
589  default: return "";
590  }
591  }
592 
593  std::string Format_Opt(int64_t i, const std::string &strip) {
594  std::string s = Format_Opt(i);
595  if (s.empty())
596  s = "(Format_Opt)" + boost::lexical_cast<std::string>(i);
597  if (boost::starts_with(s, strip))
598  s = s.substr(strip.size());
599  return s;
600  }
601 
602  const std::vector<int64_t>& Format_Opt() {
603  static const int64_t values[] = {
604  0L,
605  1L,
606  2L,
607  3L,
608  4L,
609  5L,
610  6L,
611  7L,
612  8L,
613  9L
614  };
615  static const std::vector<int64_t> retval(values, values + 10);
616  return retval;
617  }
618 
619 }
620 
621 namespace Rose {
622  std::string stringifyFormat_Opt(int64_t i, const char *strip, bool canonic) {
623  std::string retval = stringify::Format_Opt(i);
624  if (retval.empty()) {
625  retval = "(Format_Opt)" + boost::lexical_cast<std::string>(i);
626  } else {
627  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
628  retval = retval.substr(strlen(strip));
629  if (canonic)
630  retval = "Format_Opt::" + retval;
631  }
632  return retval;
633  }
634 
635  const std::vector<int64_t>& stringifyFormat_Opt() {
636  return stringify::Format_Opt();
637  }
638 }
639 
640 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
641 // /src/backend/unparser/astUnparseAttribute.h line 33
642 namespace stringify { namespace AstUnparseAttribute {
643  const char* RelativePositionType(int64_t i) {
644  switch (i) {
645  case 0L: return "e_defaultValue";
646  case 1L: return "e_undef";
647  case 2L: return "e_before";
648  case 3L: return "e_after";
649  case 4L: return "e_inside";
650  case 5L: return "e_replace";
651  case 6L: return "e_before_syntax";
652  case 7L: return "e_after_syntax";
653  default: return "";
654  }
655  }
656 
657  std::string RelativePositionType(int64_t i, const std::string &strip) {
658  std::string s = RelativePositionType(i);
659  if (s.empty())
660  s = "(AstUnparseAttribute::RelativePositionType)" + boost::lexical_cast<std::string>(i);
661  if (boost::starts_with(s, strip))
662  s = s.substr(strip.size());
663  return s;
664  }
665 
666  const std::vector<int64_t>& RelativePositionType() {
667  static const int64_t values[] = {
668  0L,
669  1L,
670  2L,
671  3L,
672  4L,
673  5L,
674  6L,
675  7L
676  };
677  static const std::vector<int64_t> retval(values, values + 8);
678  return retval;
679  }
680 
681 }}
682 
683 namespace Rose {
684  std::string stringifyAstUnparseAttributeRelativePositionType(int64_t i, const char *strip, bool canonic) {
686  if (retval.empty()) {
687  retval = "(AstUnparseAttribute::RelativePositionType)" + boost::lexical_cast<std::string>(i);
688  } else {
689  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
690  retval = retval.substr(strlen(strip));
691  if (canonic)
692  retval = "AstUnparseAttribute::RelativePositionType::" + retval;
693  }
694  return retval;
695  }
696 
697  const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType() {
699  }
700 }
701 
702 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
703 // /src/backend/unparser/unparser.h line 205
704 namespace stringify { namespace Unparser {
705  const char* token_sequence_position_enum_type(int64_t i) {
706  switch (i) {
707  case 0L: return "e_leading_whitespace_start";
708  case 1L: return "e_leading_whitespace_end";
709  case 2L: return "e_token_subsequence_start";
710  case 3L: return "e_token_subsequence_end";
711  case 4L: return "e_trailing_whitespace_start";
712  case 5L: return "e_trailing_whitespace_end";
713  default: return "";
714  }
715  }
716 
717  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
718  std::string s = token_sequence_position_enum_type(i);
719  if (s.empty())
720  s = "(Unparser::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
721  if (boost::starts_with(s, strip))
722  s = s.substr(strip.size());
723  return s;
724  }
725 
726  const std::vector<int64_t>& token_sequence_position_enum_type() {
727  static const int64_t values[] = {
728  0L,
729  1L,
730  2L,
731  3L,
732  4L,
733  5L
734  };
735  static const std::vector<int64_t> retval(values, values + 6);
736  return retval;
737  }
738 
739 }}
740 
741 namespace Rose {
742  std::string stringifyUnparser_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
744  if (retval.empty()) {
745  retval = "(Unparser::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
746  } else {
747  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
748  retval = retval.substr(strlen(strip));
749  if (canonic)
750  retval = "Unparser::token_sequence_position_enum_type::" + retval;
751  }
752  return retval;
753  }
754 
755  const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type() {
757  }
758 }
759 
760 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
761 // /src/backend/asmUnparser/AsmUnparser.h line 251
762 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AsmUnparser {
763  const char* Organization(int64_t i) {
764  switch (i) {
765  case 0L: return "ORGANIZED_BY_AST";
766  case 1L: return "ORGANIZED_BY_ADDRESS";
767  default: return "";
768  }
769  }
770 
771  std::string Organization(int64_t i, const std::string &strip) {
772  std::string s = Organization(i);
773  if (s.empty())
774  s = "(Rose::BinaryAnalysis::AsmUnparser::Organization)" + boost::lexical_cast<std::string>(i);
775  if (boost::starts_with(s, strip))
776  s = s.substr(strip.size());
777  return s;
778  }
779 
780  const std::vector<int64_t>& Organization() {
781  static const int64_t values[] = {
782  0L,
783  1L
784  };
785  static const std::vector<int64_t> retval(values, values + 2);
786  return retval;
787  }
788 
789 }}}}
790 
791 namespace Rose {
792  std::string stringifyBinaryAnalysisAsmUnparserOrganization(int64_t i, const char *strip, bool canonic) {
794  if (retval.empty()) {
795  retval = "(Rose::BinaryAnalysis::AsmUnparser::Organization)" + boost::lexical_cast<std::string>(i);
796  } else {
797  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
798  retval = retval.substr(strlen(strip));
799  if (canonic)
800  retval = "Rose::BinaryAnalysis::AsmUnparser::Organization::" + retval;
801  }
802  return retval;
803  }
804 
805  const std::vector<int64_t>& stringifyBinaryAnalysisAsmUnparserOrganization() {
807  }
808 }
809 
810 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
811 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 31
812 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
813  const char* OutputPart(int64_t i) {
814  switch (i) {
815  case 0L: return "FIRST_LINE";
816  case 1L: return "LAST_LINE";
817  case 2L: return "MIDDLE_LINE";
818  case 3L: return "INTER_LINE";
819  default: return "";
820  }
821  }
822 
823  std::string OutputPart(int64_t i, const std::string &strip) {
824  std::string s = OutputPart(i);
825  if (s.empty())
826  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart)" + boost::lexical_cast<std::string>(i);
827  if (boost::starts_with(s, strip))
828  s = s.substr(strip.size());
829  return s;
830  }
831 
832  const std::vector<int64_t>& OutputPart() {
833  static const int64_t values[] = {
834  0L,
835  1L,
836  2L,
837  3L
838  };
839  static const std::vector<int64_t> retval(values, values + 4);
840  return retval;
841  }
842 
843 }}}}}
844 
845 namespace Rose {
846  std::string stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart(int64_t i, const char *strip, bool canonic) {
848  if (retval.empty()) {
849  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart)" + boost::lexical_cast<std::string>(i);
850  } else {
851  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
852  retval = retval.substr(strlen(strip));
853  if (canonic)
854  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart::" + retval;
855  }
856  return retval;
857  }
858 
859  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart() {
861  }
862 }
863 
864 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
865 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 59
866 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
867  const char* ArrowStylePreset(int64_t i) {
868  switch (i) {
869  case 0L: return "UNICODE_1";
870  case 1L: return "UNICODE_2";
871  case 2L: return "ASCII_1";
872  case 3L: return "ASCII_2";
873  case 4L: return "ASCII_3";
874  default: return "";
875  }
876  }
877 
878  std::string ArrowStylePreset(int64_t i, const std::string &strip) {
879  std::string s = ArrowStylePreset(i);
880  if (s.empty())
881  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset)" + boost::lexical_cast<std::string>(i);
882  if (boost::starts_with(s, strip))
883  s = s.substr(strip.size());
884  return s;
885  }
886 
887  const std::vector<int64_t>& ArrowStylePreset() {
888  static const int64_t values[] = {
889  0L,
890  1L,
891  2L,
892  3L,
893  4L
894  };
895  static const std::vector<int64_t> retval(values, values + 5);
896  return retval;
897  }
898 
899 }}}}}
900 
901 namespace Rose {
902  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset(int64_t i, const char *strip, bool canonic) {
904  if (retval.empty()) {
905  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset)" + boost::lexical_cast<std::string>(i);
906  } else {
907  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
908  retval = retval.substr(strlen(strip));
909  if (canonic)
910  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset::" + retval;
911  }
912  return retval;
913  }
914 
915  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset() {
917  }
918 }
919 
920 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
921 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 68
922 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
923  const char* ArrowSide(int64_t i) {
924  switch (i) {
925  case 0L: return "LEFT";
926  case 1L: return "RIGHT";
927  default: return "";
928  }
929  }
930 
931  std::string ArrowSide(int64_t i, const std::string &strip) {
932  std::string s = ArrowSide(i);
933  if (s.empty())
934  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide)" + boost::lexical_cast<std::string>(i);
935  if (boost::starts_with(s, strip))
936  s = s.substr(strip.size());
937  return s;
938  }
939 
940  const std::vector<int64_t>& ArrowSide() {
941  static const int64_t values[] = {
942  0L,
943  1L
944  };
945  static const std::vector<int64_t> retval(values, values + 2);
946  return retval;
947  }
948 
949 }}}}}
950 
951 namespace Rose {
952  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide(int64_t i, const char *strip, bool canonic) {
954  if (retval.empty()) {
955  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide)" + boost::lexical_cast<std::string>(i);
956  } else {
957  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
958  retval = retval.substr(strlen(strip));
959  if (canonic)
960  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide::" + retval;
961  }
962  return retval;
963  }
964 
965  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide() {
967  }
968 }
969 
970 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
971 // /src/backend/asmUnparser/BinarySerialIo.h line 119
972 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
973  const char* Format(int64_t i) {
974  switch (i) {
975  case 0L: return "BINARY";
976  case 1L: return "TEXT";
977  case 2L: return "XML";
978  default: return "";
979  }
980  }
981 
982  std::string Format(int64_t i, const std::string &strip) {
983  std::string s = Format(i);
984  if (s.empty())
985  s = "(Rose::BinaryAnalysis::SerialIo::Format)" + boost::lexical_cast<std::string>(i);
986  if (boost::starts_with(s, strip))
987  s = s.substr(strip.size());
988  return s;
989  }
990 
991  const std::vector<int64_t>& Format() {
992  static const int64_t values[] = {
993  0L,
994  1L,
995  2L
996  };
997  static const std::vector<int64_t> retval(values, values + 3);
998  return retval;
999  }
1000 
1001 }}}}
1002 
1003 namespace Rose {
1004  std::string stringifyBinaryAnalysisSerialIoFormat(int64_t i, const char *strip, bool canonic) {
1005  std::string retval = stringify::Rose::BinaryAnalysis::SerialIo::Format(i);
1006  if (retval.empty()) {
1007  retval = "(Rose::BinaryAnalysis::SerialIo::Format)" + boost::lexical_cast<std::string>(i);
1008  } else {
1009  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1010  retval = retval.substr(strlen(strip));
1011  if (canonic)
1012  retval = "Rose::BinaryAnalysis::SerialIo::Format::" + retval;
1013  }
1014  return retval;
1015  }
1016 
1017  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoFormat() {
1019  }
1020 }
1021 
1022 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1023 // /src/backend/asmUnparser/BinarySerialIo.h line 130
1024 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
1025  const char* Savable(int64_t i) {
1026  switch (i) {
1027  case 0L: return "NO_OBJECT";
1028  case 1L: return "PARTITIONER";
1029  case 2L: return "AST";
1030  case 65534L: return "END_OF_DATA";
1031  case 65535L: return "ERROR";
1032  case 65536L: return "USER_DEFINED";
1033  case 4294967295L: return "USER_DEFINED_LAST";
1034  default: return "";
1035  }
1036  }
1037 
1038  std::string Savable(int64_t i, const std::string &strip) {
1039  std::string s = Savable(i);
1040  if (s.empty())
1041  s = "(Rose::BinaryAnalysis::SerialIo::Savable)" + boost::lexical_cast<std::string>(i);
1042  if (boost::starts_with(s, strip))
1043  s = s.substr(strip.size());
1044  return s;
1045  }
1046 
1047  const std::vector<int64_t>& Savable() {
1048  static const int64_t values[] = {
1049  0L,
1050  1L,
1051  2L,
1052  65534L,
1053  65535L,
1054  65536L,
1055  4294967295L
1056  };
1057  static const std::vector<int64_t> retval(values, values + 7);
1058  return retval;
1059  }
1060 
1061 }}}}
1062 
1063 namespace Rose {
1064  std::string stringifyBinaryAnalysisSerialIoSavable(int64_t i, const char *strip, bool canonic) {
1066  if (retval.empty()) {
1067  retval = "(Rose::BinaryAnalysis::SerialIo::Savable)" + boost::lexical_cast<std::string>(i);
1068  } else {
1069  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1070  retval = retval.substr(strlen(strip));
1071  if (canonic)
1072  retval = "Rose::BinaryAnalysis::SerialIo::Savable::" + retval;
1073  }
1074  return retval;
1075  }
1076 
1077  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoSavable() {
1079  }
1080 }
1081 
1082 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1083 // /src/backend/asmUnparser/BinaryUnparserBase.h line 37
1084 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace ArrowMargin {
1085  const char* Flags(int64_t i) {
1086  switch (i) {
1087  case 1L: return "POINTABLE_ENTITY_START";
1088  case 2L: return "POINTABLE_ENTITY_END";
1089  case 4L: return "POINTABLE_ENTITY_INSIDE";
1090  case 8L: return "ALWAYS_RENDER";
1091  default: return "";
1092  }
1093  }
1094 
1095  std::string Flags(int64_t i, const std::string &strip) {
1096  std::string s = Flags(i);
1097  if (s.empty())
1098  s = "(Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags)" + boost::lexical_cast<std::string>(i);
1099  if (boost::starts_with(s, strip))
1100  s = s.substr(strip.size());
1101  return s;
1102  }
1103 
1104  const std::vector<int64_t>& Flags() {
1105  static const int64_t values[] = {
1106  1L,
1107  2L,
1108  4L,
1109  8L
1110  };
1111  static const std::vector<int64_t> retval(values, values + 4);
1112  return retval;
1113  }
1114 
1115 }}}}}
1116 
1117 namespace Rose {
1118  std::string stringifyBinaryAnalysisUnparserArrowMarginFlags(int64_t i, const char *strip, bool canonic) {
1120  if (retval.empty()) {
1121  retval = "(Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags)" + boost::lexical_cast<std::string>(i);
1122  } else {
1123  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1124  retval = retval.substr(strlen(strip));
1125  if (canonic)
1126  retval = "Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags::" + retval;
1127  }
1128  return retval;
1129  }
1130 
1131  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserArrowMarginFlags() {
1133  }
1134 }
1135 
1136 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1137 // /src/backend/asmUnparser/AsmUnparser_compat.h line 46
1138 namespace stringify {
1139  const char* ArmSignForExpressionUnparsing(int64_t i) {
1140  switch (i) {
1141  case 0L: return "arm_sign_none";
1142  case 1L: return "arm_sign_plus";
1143  case 2L: return "arm_sign_minus";
1144  default: return "";
1145  }
1146  }
1147 
1148  std::string ArmSignForExpressionUnparsing(int64_t i, const std::string &strip) {
1149  std::string s = ArmSignForExpressionUnparsing(i);
1150  if (s.empty())
1151  s = "(ArmSignForExpressionUnparsing)" + boost::lexical_cast<std::string>(i);
1152  if (boost::starts_with(s, strip))
1153  s = s.substr(strip.size());
1154  return s;
1155  }
1156 
1157  const std::vector<int64_t>& ArmSignForExpressionUnparsing() {
1158  static const int64_t values[] = {
1159  0L,
1160  1L,
1161  2L
1162  };
1163  static const std::vector<int64_t> retval(values, values + 3);
1164  return retval;
1165  }
1166 
1167 }
1168 
1169 namespace Rose {
1170  std::string stringifyArmSignForExpressionUnparsing(int64_t i, const char *strip, bool canonic) {
1171  std::string retval = stringify::ArmSignForExpressionUnparsing(i);
1172  if (retval.empty()) {
1173  retval = "(ArmSignForExpressionUnparsing)" + boost::lexical_cast<std::string>(i);
1174  } else {
1175  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1176  retval = retval.substr(strlen(strip));
1177  if (canonic)
1178  retval = "ArmSignForExpressionUnparsing::" + retval;
1179  }
1180  return retval;
1181  }
1182 
1183  const std::vector<int64_t>& stringifyArmSignForExpressionUnparsing() {
1185  }
1186 }
1187 
1188 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1189 // /src/midend/KLT/include/KLT/Core/descriptor.hpp line 18
1190 namespace stringify { namespace KLT { namespace Descriptor {
1191  const char* tile_kind_e(int64_t i) {
1192  switch (i) {
1193  case -1L: return "e_not_tile";
1194  case 0L: return "e_static_tile";
1195  case 1L: return "e_last_klt_tile";
1196  default: return "";
1197  }
1198  }
1199 
1200  std::string tile_kind_e(int64_t i, const std::string &strip) {
1201  std::string s = tile_kind_e(i);
1202  if (s.empty())
1203  s = "(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
1204  if (boost::starts_with(s, strip))
1205  s = s.substr(strip.size());
1206  return s;
1207  }
1208 
1209  const std::vector<int64_t>& tile_kind_e() {
1210  static const int64_t values[] = {
1211  -1L,
1212  0L,
1213  1L
1214  };
1215  static const std::vector<int64_t> retval(values, values + 3);
1216  return retval;
1217  }
1218 
1219 }}}
1220 
1221 namespace Rose {
1222  std::string stringifyKLT_Descriptor_tile_kind_e(int64_t i, const char *strip, bool canonic) {
1223  std::string retval = stringify::KLT::Descriptor::tile_kind_e(i);
1224  if (retval.empty()) {
1225  retval = "(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
1226  } else {
1227  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1228  retval = retval.substr(strlen(strip));
1229  if (canonic)
1230  retval = "KLT::Descriptor::tile_kind_e::" + retval;
1231  }
1232  return retval;
1233  }
1234 
1235  const std::vector<int64_t>& stringifyKLT_Descriptor_tile_kind_e() {
1237  }
1238 }
1239 
1240 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1241 // /src/midend/KLT/include/KLT/Core/looptree.hpp line 30
1242 namespace stringify { namespace KLT { namespace LoopTree {
1243  const char* kind_e(int64_t i) {
1244  switch (i) {
1245  case 0L: return "e_block";
1246  case 1L: return "e_cond";
1247  case 2L: return "e_loop";
1248  case 3L: return "e_tile";
1249  case 4L: return "e_stmt";
1250  case 5L: return "e_ignored";
1251  case 6L: return "e_unknown";
1252  default: return "";
1253  }
1254  }
1255 
1256  std::string kind_e(int64_t i, const std::string &strip) {
1257  std::string s = kind_e(i);
1258  if (s.empty())
1259  s = "(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
1260  if (boost::starts_with(s, strip))
1261  s = s.substr(strip.size());
1262  return s;
1263  }
1264 
1265  const std::vector<int64_t>& kind_e() {
1266  static const int64_t values[] = {
1267  0L,
1268  1L,
1269  2L,
1270  3L,
1271  4L,
1272  5L,
1273  6L
1274  };
1275  static const std::vector<int64_t> retval(values, values + 7);
1276  return retval;
1277  }
1278 
1279 }}}
1280 
1281 namespace Rose {
1282  std::string stringifyKLT_LoopTree_kind_e(int64_t i, const char *strip, bool canonic) {
1283  std::string retval = stringify::KLT::LoopTree::kind_e(i);
1284  if (retval.empty()) {
1285  retval = "(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
1286  } else {
1287  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1288  retval = retval.substr(strlen(strip));
1289  if (canonic)
1290  retval = "KLT::LoopTree::kind_e::" + retval;
1291  }
1292  return retval;
1293  }
1294 
1295  const std::vector<int64_t>& stringifyKLT_LoopTree_kind_e() {
1297  }
1298 }
1299 
1300 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1301 // /src/midend/KLT/include/KLT/RTL/tile.h line 7
1302 namespace stringify { namespace klt_tile_desc_t {
1303  const char* tile_kind_e(int64_t i) {
1304  switch (i) {
1305  case 0L: return "e_tile_static";
1306  case 1L: return "e_tile_dynamic";
1307  default: return "";
1308  }
1309  }
1310 
1311  std::string tile_kind_e(int64_t i, const std::string &strip) {
1312  std::string s = tile_kind_e(i);
1313  if (s.empty())
1314  s = "(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
1315  if (boost::starts_with(s, strip))
1316  s = s.substr(strip.size());
1317  return s;
1318  }
1319 
1320  const std::vector<int64_t>& tile_kind_e() {
1321  static const int64_t values[] = {
1322  0L,
1323  1L
1324  };
1325  static const std::vector<int64_t> retval(values, values + 2);
1326  return retval;
1327  }
1328 
1329 }}
1330 
1331 namespace Rose {
1332  std::string stringify_klt_tile_desc_t_tile_kind_e(int64_t i, const char *strip, bool canonic) {
1333  std::string retval = stringify::klt_tile_desc_t::tile_kind_e(i);
1334  if (retval.empty()) {
1335  retval = "(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
1336  } else {
1337  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1338  retval = retval.substr(strlen(strip));
1339  if (canonic)
1340  retval = "klt_tile_desc_t::tile_kind_e::" + retval;
1341  }
1342  return retval;
1343  }
1344 
1345  const std::vector<int64_t>& stringify_klt_tile_desc_t_tile_kind_e() {
1347  }
1348 }
1349 
1350 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1351 // /src/midend/astProcessing/AstAttributeMechanism.C line 21
1352 namespace stringify {
1353  const char* WarningType(int64_t i) {
1354  switch (i) {
1355  case 0L: return "HAS_MEMORY_LEAK";
1356  case 1L: return "HAS_UNKNOWN_OWNERSHIP";
1357  case 2L: return "HAS_NULL_COPY";
1358  case 3L: return "HAS_SELF_COPY";
1359  case 4L: return "HAS_NO_CLASS_NAME";
1360  default: return "";
1361  }
1362  }
1363 
1364  std::string WarningType(int64_t i, const std::string &strip) {
1365  std::string s = WarningType(i);
1366  if (s.empty())
1367  s = "(WarningType)" + boost::lexical_cast<std::string>(i);
1368  if (boost::starts_with(s, strip))
1369  s = s.substr(strip.size());
1370  return s;
1371  }
1372 
1373  const std::vector<int64_t>& WarningType() {
1374  static const int64_t values[] = {
1375  0L,
1376  1L,
1377  2L,
1378  3L,
1379  4L
1380  };
1381  static const std::vector<int64_t> retval(values, values + 5);
1382  return retval;
1383  }
1384 
1385 }
1386 
1387 namespace Rose {
1388  std::string stringifyWarningType(int64_t i, const char *strip, bool canonic) {
1389  std::string retval = stringify::WarningType(i);
1390  if (retval.empty()) {
1391  retval = "(WarningType)" + boost::lexical_cast<std::string>(i);
1392  } else {
1393  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1394  retval = retval.substr(strlen(strip));
1395  if (canonic)
1396  retval = "WarningType::" + retval;
1397  }
1398  return retval;
1399  }
1400 
1401  const std::vector<int64_t>& stringifyWarningType() {
1402  return stringify::WarningType();
1403  }
1404 }
1405 
1406 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1407 // /src/midend/astProcessing/AstAttributeMechanism.h line 42
1408 namespace stringify { namespace AstAttribute {
1409  const char* OwnershipPolicy(int64_t i) {
1410  switch (i) {
1411  case 0L: return "CONTAINER_OWNERSHIP";
1412  case 1L: return "NO_OWNERSHIP";
1413  case 2L: return "CUSTOM_OWNERSHIP";
1414  case 3L: return "UNKNOWN_OWNERSHIP";
1415  default: return "";
1416  }
1417  }
1418 
1419  std::string OwnershipPolicy(int64_t i, const std::string &strip) {
1420  std::string s = OwnershipPolicy(i);
1421  if (s.empty())
1422  s = "(AstAttribute::OwnershipPolicy)" + boost::lexical_cast<std::string>(i);
1423  if (boost::starts_with(s, strip))
1424  s = s.substr(strip.size());
1425  return s;
1426  }
1427 
1428  const std::vector<int64_t>& OwnershipPolicy() {
1429  static const int64_t values[] = {
1430  0L,
1431  1L,
1432  2L,
1433  3L
1434  };
1435  static const std::vector<int64_t> retval(values, values + 4);
1436  return retval;
1437  }
1438 
1439 }}
1440 
1441 namespace Rose {
1442  std::string stringifyAstAttributeOwnershipPolicy(int64_t i, const char *strip, bool canonic) {
1443  std::string retval = stringify::AstAttribute::OwnershipPolicy(i);
1444  if (retval.empty()) {
1445  retval = "(AstAttribute::OwnershipPolicy)" + boost::lexical_cast<std::string>(i);
1446  } else {
1447  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1448  retval = retval.substr(strlen(strip));
1449  if (canonic)
1450  retval = "AstAttribute::OwnershipPolicy::" + retval;
1451  }
1452  return retval;
1453  }
1454 
1455  const std::vector<int64_t>& stringifyAstAttributeOwnershipPolicy() {
1457  }
1458 }
1459 
1460 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1461 // /src/midend/astQuery/nodeQuery.h line 133
1462 namespace stringify { namespace NodeQuery {
1463  const char* TypeOfQueryTypeOneParameter(int64_t i) {
1464  switch (i) {
1465  case 0L: return "UnknownListElementType";
1466  case 1L: return "VariableDeclarations";
1467  case 2L: return "VariableTypes";
1468  case 3L: return "FunctionDeclarations";
1469  case 4L: return "MemberFunctionDeclarations";
1470  case 5L: return "ClassDeclarations";
1471  case 6L: return "StructDeclarations";
1472  case 7L: return "UnionDeclarations";
1473  case 8L: return "Arguments";
1474  case 9L: return "ClassFields";
1475  case 10L: return "StructFields";
1476  case 11L: return "UnionFields";
1477  case 12L: return "StructDefinitions";
1478  case 13L: return "TypedefDeclarations";
1479  case 14L: return "AnonymousTypedefs";
1480  case 15L: return "AnonymousTypedefClassDeclarations";
1481  case 16L: return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
1482  default: return "";
1483  }
1484  }
1485 
1486  std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
1487  std::string s = TypeOfQueryTypeOneParameter(i);
1488  if (s.empty())
1489  s = "(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1490  if (boost::starts_with(s, strip))
1491  s = s.substr(strip.size());
1492  return s;
1493  }
1494 
1495  const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
1496  static const int64_t values[] = {
1497  0L,
1498  1L,
1499  2L,
1500  3L,
1501  4L,
1502  5L,
1503  6L,
1504  7L,
1505  8L,
1506  9L,
1507  10L,
1508  11L,
1509  12L,
1510  13L,
1511  14L,
1512  15L,
1513  16L
1514  };
1515  static const std::vector<int64_t> retval(values, values + 17);
1516  return retval;
1517  }
1518 
1519 }}
1520 
1521 namespace Rose {
1522  std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
1523  std::string retval = stringify::NodeQuery::TypeOfQueryTypeOneParameter(i);
1524  if (retval.empty()) {
1525  retval = "(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1526  } else {
1527  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1528  retval = retval.substr(strlen(strip));
1529  if (canonic)
1530  retval = "NodeQuery::TypeOfQueryTypeOneParameter::" + retval;
1531  }
1532  return retval;
1533  }
1534 
1535  const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter() {
1537  }
1538 }
1539 
1540 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1541 // /src/midend/astQuery/nodeQuery.h line 154
1542 namespace stringify { namespace NodeQuery {
1543  const char* TypeOfQueryTypeTwoParameters(int64_t i) {
1544  switch (i) {
1545  case 0L: return "UnknownListElementTypeTwoParameters";
1546  case 1L: return "FunctionDeclarationFromDefinition";
1547  case 2L: return "ClassDeclarationFromName";
1548  case 3L: return "ClassDeclarationsFromTypeName";
1549  case 4L: return "PragmaDeclarationFromName";
1550  case 5L: return "VariableDeclarationFromName";
1551  case 6L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
1552  default: return "";
1553  }
1554  }
1555 
1556  std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
1557  std::string s = TypeOfQueryTypeTwoParameters(i);
1558  if (s.empty())
1559  s = "(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1560  if (boost::starts_with(s, strip))
1561  s = s.substr(strip.size());
1562  return s;
1563  }
1564 
1565  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
1566  static const int64_t values[] = {
1567  0L,
1568  1L,
1569  2L,
1570  3L,
1571  4L,
1572  5L,
1573  6L
1574  };
1575  static const std::vector<int64_t> retval(values, values + 7);
1576  return retval;
1577  }
1578 
1579 }}
1580 
1581 namespace Rose {
1582  std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
1584  if (retval.empty()) {
1585  retval = "(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1586  } else {
1587  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1588  retval = retval.substr(strlen(strip));
1589  if (canonic)
1590  retval = "NodeQuery::TypeOfQueryTypeTwoParameters::" + retval;
1591  }
1592  return retval;
1593  }
1594 
1595  const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters() {
1597  }
1598 }
1599 
1600 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1601 // /src/midend/astQuery/astQuery.h line 96
1602 namespace stringify { namespace AstQueryNamespace {
1603  const char* QueryDepth(int64_t i) {
1604  switch (i) {
1605  case 0L: return "UnknownListElementTypeQueryDepth";
1606  case 1L: return "ChildrenOnly";
1607  case 2L: return "AllNodes";
1608  case 3L: return "ExtractTypes";
1609  case 4L: return "END_OF_NODE_TYPE_LIST_QUERY_DEPTH";
1610  default: return "";
1611  }
1612  }
1613 
1614  std::string QueryDepth(int64_t i, const std::string &strip) {
1615  std::string s = QueryDepth(i);
1616  if (s.empty())
1617  s = "(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
1618  if (boost::starts_with(s, strip))
1619  s = s.substr(strip.size());
1620  return s;
1621  }
1622 
1623  const std::vector<int64_t>& QueryDepth() {
1624  static const int64_t values[] = {
1625  0L,
1626  1L,
1627  2L,
1628  3L,
1629  4L
1630  };
1631  static const std::vector<int64_t> retval(values, values + 5);
1632  return retval;
1633  }
1634 
1635 }}
1636 
1637 namespace Rose {
1638  std::string stringifyAstQueryNamespaceQueryDepth(int64_t i, const char *strip, bool canonic) {
1639  std::string retval = stringify::AstQueryNamespace::QueryDepth(i);
1640  if (retval.empty()) {
1641  retval = "(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
1642  } else {
1643  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1644  retval = retval.substr(strlen(strip));
1645  if (canonic)
1646  retval = "AstQueryNamespace::QueryDepth::" + retval;
1647  }
1648  return retval;
1649  }
1650 
1651  const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth() {
1653  }
1654 }
1655 
1656 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1657 // /src/midend/astQuery/nameQuery.h line 74
1658 namespace stringify { namespace NameQuery {
1659  const char* TypeOfQueryTypeOneParameter(int64_t i) {
1660  switch (i) {
1661  case 0L: return "UnknownListElementType";
1662  case 1L: return "VariableNames";
1663  case 2L: return "VariableTypeNames";
1664  case 3L: return "FunctionDeclarationNames";
1665  case 4L: return "MemberFunctionDeclarationNames";
1666  case 5L: return "ClassDeclarationNames";
1667  case 6L: return "ArgumentNames";
1668  case 7L: return "ClassFieldNames";
1669  case 8L: return "UnionFieldNames";
1670  case 9L: return "StructFieldNames";
1671  case 10L: return "FunctionReferenceNames";
1672  case 11L: return "StructNames";
1673  case 12L: return "UnionNames";
1674  case 13L: return "TypedefDeclarationNames";
1675  case 14L: return "TypeNames";
1676  case 15L: return "END_OF_NAME_TYPE_LIST";
1677  default: return "";
1678  }
1679  }
1680 
1681  std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
1682  std::string s = TypeOfQueryTypeOneParameter(i);
1683  if (s.empty())
1684  s = "(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1685  if (boost::starts_with(s, strip))
1686  s = s.substr(strip.size());
1687  return s;
1688  }
1689 
1690  const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
1691  static const int64_t values[] = {
1692  0L,
1693  1L,
1694  2L,
1695  3L,
1696  4L,
1697  5L,
1698  6L,
1699  7L,
1700  8L,
1701  9L,
1702  10L,
1703  11L,
1704  12L,
1705  13L,
1706  14L,
1707  15L
1708  };
1709  static const std::vector<int64_t> retval(values, values + 16);
1710  return retval;
1711  }
1712 
1713 }}
1714 
1715 namespace Rose {
1716  std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
1717  std::string retval = stringify::NameQuery::TypeOfQueryTypeOneParameter(i);
1718  if (retval.empty()) {
1719  retval = "(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1720  } else {
1721  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1722  retval = retval.substr(strlen(strip));
1723  if (canonic)
1724  retval = "NameQuery::TypeOfQueryTypeOneParameter::" + retval;
1725  }
1726  return retval;
1727  }
1728 
1729  const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter() {
1731  }
1732 }
1733 
1734 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1735 // /src/midend/astQuery/nameQuery.h line 94
1736 namespace stringify { namespace NameQuery {
1737  const char* TypeOfQueryTypeTwoParameters(int64_t i) {
1738  switch (i) {
1739  case 0L: return "UnknownListElementTypeTwoParameters";
1740  case 1L: return "VariableNamesWithTypeName";
1741  case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
1742  default: return "";
1743  }
1744  }
1745 
1746  std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
1747  std::string s = TypeOfQueryTypeTwoParameters(i);
1748  if (s.empty())
1749  s = "(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1750  if (boost::starts_with(s, strip))
1751  s = s.substr(strip.size());
1752  return s;
1753  }
1754 
1755  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
1756  static const int64_t values[] = {
1757  0L,
1758  1L,
1759  2L
1760  };
1761  static const std::vector<int64_t> retval(values, values + 3);
1762  return retval;
1763  }
1764 
1765 }}
1766 
1767 namespace Rose {
1768  std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
1770  if (retval.empty()) {
1771  retval = "(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1772  } else {
1773  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1774  retval = retval.substr(strlen(strip));
1775  if (canonic)
1776  retval = "NameQuery::TypeOfQueryTypeTwoParameters::" + retval;
1777  }
1778  return retval;
1779  }
1780 
1781  const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters() {
1783  }
1784 }
1785 
1786 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1787 // /src/midend/astQuery/booleanQuery.h line 43
1788 namespace stringify { namespace BooleanQuery {
1789  const char* TypeOfQueryType(int64_t i) {
1790  switch (i) {
1791  case 0L: return "UnknownListElementType";
1792  case 1L: return "VariableDeclaration";
1793  case 2L: return "Type";
1794  case 3L: return "FunctionDeclaration";
1795  case 4L: return "MemberFunctionDeclaration";
1796  case 5L: return "ClassDeclaration";
1797  case 6L: return "Argument";
1798  case 7L: return "Field";
1799  case 8L: return "UnionedField";
1800  case 9L: return "Struct";
1801  case 10L: return "ContainedInSubtreeOfType";
1802  case 11L: return "END_OF_BOOLEAN_QUERY_TYPE";
1803  default: return "";
1804  }
1805  }
1806 
1807  std::string TypeOfQueryType(int64_t i, const std::string &strip) {
1808  std::string s = TypeOfQueryType(i);
1809  if (s.empty())
1810  s = "(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
1811  if (boost::starts_with(s, strip))
1812  s = s.substr(strip.size());
1813  return s;
1814  }
1815 
1816  const std::vector<int64_t>& TypeOfQueryType() {
1817  static const int64_t values[] = {
1818  0L,
1819  1L,
1820  2L,
1821  3L,
1822  4L,
1823  5L,
1824  6L,
1825  7L,
1826  8L,
1827  9L,
1828  10L,
1829  11L
1830  };
1831  static const std::vector<int64_t> retval(values, values + 12);
1832  return retval;
1833  }
1834 
1835 }}
1836 
1837 namespace Rose {
1838  std::string stringifyBooleanQueryTypeOfQueryType(int64_t i, const char *strip, bool canonic) {
1839  std::string retval = stringify::BooleanQuery::TypeOfQueryType(i);
1840  if (retval.empty()) {
1841  retval = "(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
1842  } else {
1843  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1844  retval = retval.substr(strlen(strip));
1845  if (canonic)
1846  retval = "BooleanQuery::TypeOfQueryType::" + retval;
1847  }
1848  return retval;
1849  }
1850 
1851  const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType() {
1853  }
1854 }
1855 
1856 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1857 // /src/midend/astQuery/numberQuery.h line 10
1858 namespace stringify { namespace NumberQuery {
1859  const char* TypeOfQueryTypeOneParameter(int64_t i) {
1860  switch (i) {
1861  case 0L: return "UnknownListElementType";
1862  case 1L: return "NumberOfArgsInConstructor";
1863  case 2L: return "NumberOfOperands";
1864  case 3L: return "NumberOfArgsInScalarIndexingOperator";
1865  case 4L: return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
1866  default: return "";
1867  }
1868  }
1869 
1870  std::string TypeOfQueryTypeOneParameter(int64_t i, const std::string &strip) {
1871  std::string s = TypeOfQueryTypeOneParameter(i);
1872  if (s.empty())
1873  s = "(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1874  if (boost::starts_with(s, strip))
1875  s = s.substr(strip.size());
1876  return s;
1877  }
1878 
1879  const std::vector<int64_t>& TypeOfQueryTypeOneParameter() {
1880  static const int64_t values[] = {
1881  0L,
1882  1L,
1883  2L,
1884  3L,
1885  4L
1886  };
1887  static const std::vector<int64_t> retval(values, values + 5);
1888  return retval;
1889  }
1890 
1891 }}
1892 
1893 namespace Rose {
1894  std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t i, const char *strip, bool canonic) {
1896  if (retval.empty()) {
1897  retval = "(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
1898  } else {
1899  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1900  retval = retval.substr(strlen(strip));
1901  if (canonic)
1902  retval = "NumberQuery::TypeOfQueryTypeOneParameter::" + retval;
1903  }
1904  return retval;
1905  }
1906 
1907  const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter() {
1909  }
1910 }
1911 
1912 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1913 // /src/midend/astQuery/numberQuery.h line 19
1914 namespace stringify { namespace NumberQuery {
1915  const char* TypeOfQueryTypeTwoParameters(int64_t i) {
1916  switch (i) {
1917  case 0L: return "UnknownListElementTypeTwoParameters";
1918  case 1L: return "NumberOfArgsInParanthesisOperator";
1919  case 2L: return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
1920  default: return "";
1921  }
1922  }
1923 
1924  std::string TypeOfQueryTypeTwoParameters(int64_t i, const std::string &strip) {
1925  std::string s = TypeOfQueryTypeTwoParameters(i);
1926  if (s.empty())
1927  s = "(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1928  if (boost::starts_with(s, strip))
1929  s = s.substr(strip.size());
1930  return s;
1931  }
1932 
1933  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters() {
1934  static const int64_t values[] = {
1935  0L,
1936  1L,
1937  2L
1938  };
1939  static const std::vector<int64_t> retval(values, values + 3);
1940  return retval;
1941  }
1942 
1943 }}
1944 
1945 namespace Rose {
1946  std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t i, const char *strip, bool canonic) {
1948  if (retval.empty()) {
1949  retval = "(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
1950  } else {
1951  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1952  retval = retval.substr(strlen(strip));
1953  if (canonic)
1954  retval = "NumberQuery::TypeOfQueryTypeTwoParameters::" + retval;
1955  }
1956  return retval;
1957  }
1958 
1959  const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters() {
1961  }
1962 }
1963 
1964 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1965 // /src/midend/abstractLayer/Labeler.h line 60
1966 namespace stringify { namespace CodeThorn { namespace LabelProperty {
1967  const char* LabelType(int64_t i) {
1968  switch (i) {
1969  case 1L: return "LABEL_UNDEF";
1970  case 2L: return "LABEL_OTHER";
1971  case 100L: return "LABEL_FUNCTIONCALL";
1972  case 101L: return "LABEL_FUNCTIONCALLRETURN";
1973  case 102L: return "LABEL_FUNCTIONENTRY";
1974  case 103L: return "LABEL_FUNCTIONEXIT";
1975  case 104L: return "LABEL_BLOCKBEGIN";
1976  case 105L: return "LABEL_BLOCKEND";
1977  case 106L: return "LABEL_EMPTY_STMT";
1978  case 107L: return "LABEL_FORK";
1979  case 108L: return "LABEL_JOIN";
1980  case 109L: return "LABEL_WORKSHARE";
1981  case 110L: return "LABEL_BARRIER";
1982  default: return "";
1983  }
1984  }
1985 
1986  std::string LabelType(int64_t i, const std::string &strip) {
1987  std::string s = LabelType(i);
1988  if (s.empty())
1989  s = "(CodeThorn::LabelProperty::LabelType)" + boost::lexical_cast<std::string>(i);
1990  if (boost::starts_with(s, strip))
1991  s = s.substr(strip.size());
1992  return s;
1993  }
1994 
1995  const std::vector<int64_t>& LabelType() {
1996  static const int64_t values[] = {
1997  1L,
1998  2L,
1999  100L,
2000  101L,
2001  102L,
2002  103L,
2003  104L,
2004  105L,
2005  106L,
2006  107L,
2007  108L,
2008  109L,
2009  110L
2010  };
2011  static const std::vector<int64_t> retval(values, values + 13);
2012  return retval;
2013  }
2014 
2015 }}}
2016 
2017 namespace Rose {
2018  std::string stringifyCodeThornLabelPropertyLabelType(int64_t i, const char *strip, bool canonic) {
2019  std::string retval = stringify::CodeThorn::LabelProperty::LabelType(i);
2020  if (retval.empty()) {
2021  retval = "(CodeThorn::LabelProperty::LabelType)" + boost::lexical_cast<std::string>(i);
2022  } else {
2023  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2024  retval = retval.substr(strlen(strip));
2025  if (canonic)
2026  retval = "CodeThorn::LabelProperty::LabelType::" + retval;
2027  }
2028  return retval;
2029  }
2030 
2031  const std::vector<int64_t>& stringifyCodeThornLabelPropertyLabelType() {
2033  }
2034 }
2035 
2036 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2037 // /src/midend/abstractLayer/Labeler.h line 94
2038 namespace stringify { namespace CodeThorn { namespace LabelProperty {
2039  const char* IOType(int64_t i) {
2040  switch (i) {
2041  case 0L: return "LABELIO_NONE";
2042  case 1L: return "LABELIO_STDIN";
2043  case 2L: return "LABELIO_STDOUTVAR";
2044  case 3L: return "LABELIO_STDOUTCONST";
2045  case 4L: return "LABELIO_STDERR";
2046  default: return "";
2047  }
2048  }
2049 
2050  std::string IOType(int64_t i, const std::string &strip) {
2051  std::string s = IOType(i);
2052  if (s.empty())
2053  s = "(CodeThorn::LabelProperty::IOType)" + boost::lexical_cast<std::string>(i);
2054  if (boost::starts_with(s, strip))
2055  s = s.substr(strip.size());
2056  return s;
2057  }
2058 
2059  const std::vector<int64_t>& IOType() {
2060  static const int64_t values[] = {
2061  0L,
2062  1L,
2063  2L,
2064  3L,
2065  4L
2066  };
2067  static const std::vector<int64_t> retval(values, values + 5);
2068  return retval;
2069  }
2070 
2071 }}}
2072 
2073 namespace Rose {
2074  std::string stringifyCodeThornLabelPropertyIOType(int64_t i, const char *strip, bool canonic) {
2075  std::string retval = stringify::CodeThorn::LabelProperty::IOType(i);
2076  if (retval.empty()) {
2077  retval = "(CodeThorn::LabelProperty::IOType)" + boost::lexical_cast<std::string>(i);
2078  } else {
2079  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2080  retval = retval.substr(strlen(strip));
2081  if (canonic)
2082  retval = "CodeThorn::LabelProperty::IOType::" + retval;
2083  }
2084  return retval;
2085  }
2086 
2087  const std::vector<int64_t>& stringifyCodeThornLabelPropertyIOType() {
2089  }
2090 }
2091 
2092 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2093 // /src/midend/abstractLayer/SgNodeHelper.h line 509
2094 namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
2095  const char* OType(int64_t i) {
2096  switch (i) {
2097  case 0L: return "VAR";
2098  case 1L: return "INT";
2099  case 2L: return "UNKNOWNPRINTF";
2100  case 3L: return "UNKNOWNOPERATION";
2101  default: return "";
2102  }
2103  }
2104 
2105  std::string OType(int64_t i, const std::string &strip) {
2106  std::string s = OType(i);
2107  if (s.empty())
2108  s = "(SgNodeHelper::Pattern::OutputTarget::OType)" + boost::lexical_cast<std::string>(i);
2109  if (boost::starts_with(s, strip))
2110  s = s.substr(strip.size());
2111  return s;
2112  }
2113 
2114  const std::vector<int64_t>& OType() {
2115  static const int64_t values[] = {
2116  0L,
2117  1L,
2118  2L,
2119  3L
2120  };
2121  static const std::vector<int64_t> retval(values, values + 4);
2122  return retval;
2123  }
2124 
2125 }}}}
2126 
2127 namespace Rose {
2128  std::string stringifySgNodeHelperPatternOutputTargetOType(int64_t i, const char *strip, bool canonic) {
2130  if (retval.empty()) {
2131  retval = "(SgNodeHelper::Pattern::OutputTarget::OType)" + boost::lexical_cast<std::string>(i);
2132  } else {
2133  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2134  retval = retval.substr(strlen(strip));
2135  if (canonic)
2136  retval = "SgNodeHelper::Pattern::OutputTarget::OType::" + retval;
2137  }
2138  return retval;
2139  }
2140 
2141  const std::vector<int64_t>& stringifySgNodeHelperPatternOutputTargetOType() {
2143  }
2144 }
2145 
2146 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2147 // /src/midend/astSnippet/Snippet.h line 319
2148 namespace stringify { namespace Rose { namespace Snippet {
2149  const char* InsertMechanism(int64_t i) {
2150  switch (i) {
2151  case 0L: return "INSERT_BODY";
2152  case 1L: return "INSERT_STMTS";
2153  default: return "";
2154  }
2155  }
2156 
2157  std::string InsertMechanism(int64_t i, const std::string &strip) {
2158  std::string s = InsertMechanism(i);
2159  if (s.empty())
2160  s = "(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
2161  if (boost::starts_with(s, strip))
2162  s = s.substr(strip.size());
2163  return s;
2164  }
2165 
2166  const std::vector<int64_t>& InsertMechanism() {
2167  static const int64_t values[] = {
2168  0L,
2169  1L
2170  };
2171  static const std::vector<int64_t> retval(values, values + 2);
2172  return retval;
2173  }
2174 
2175 }}}
2176 
2177 namespace Rose {
2178  std::string stringifySnippetInsertMechanism(int64_t i, const char *strip, bool canonic) {
2179  std::string retval = stringify::Rose::Snippet::InsertMechanism(i);
2180  if (retval.empty()) {
2181  retval = "(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
2182  } else {
2183  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2184  retval = retval.substr(strlen(strip));
2185  if (canonic)
2186  retval = "Rose::Snippet::InsertMechanism::" + retval;
2187  }
2188  return retval;
2189  }
2190 
2191  const std::vector<int64_t>& stringifySnippetInsertMechanism() {
2193  }
2194 }
2195 
2196 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2197 // /src/midend/astSnippet/Snippet.h line 329
2198 namespace stringify { namespace Rose { namespace Snippet {
2199  const char* LocalDeclarationPosition(int64_t i) {
2200  switch (i) {
2201  case 0L: return "LOCDECLS_AT_BEGINNING";
2202  case 1L: return "LOCDECLS_AT_END";
2203  case 2L: return "LOCDECLS_AT_CURSOR";
2204  default: return "";
2205  }
2206  }
2207 
2208  std::string LocalDeclarationPosition(int64_t i, const std::string &strip) {
2209  std::string s = LocalDeclarationPosition(i);
2210  if (s.empty())
2211  s = "(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
2212  if (boost::starts_with(s, strip))
2213  s = s.substr(strip.size());
2214  return s;
2215  }
2216 
2217  const std::vector<int64_t>& LocalDeclarationPosition() {
2218  static const int64_t values[] = {
2219  0L,
2220  1L,
2221  2L
2222  };
2223  static const std::vector<int64_t> retval(values, values + 3);
2224  return retval;
2225  }
2226 
2227 }}}
2228 
2229 namespace Rose {
2230  std::string stringifySnippetLocalDeclarationPosition(int64_t i, const char *strip, bool canonic) {
2232  if (retval.empty()) {
2233  retval = "(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
2234  } else {
2235  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2236  retval = retval.substr(strlen(strip));
2237  if (canonic)
2238  retval = "Rose::Snippet::LocalDeclarationPosition::" + retval;
2239  }
2240  return retval;
2241  }
2242 
2243  const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition() {
2245  }
2246 }
2247 
2248 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2249 // /src/midend/astRewriteMechanism/rewrite.h line 52
2250 namespace stringify { namespace MidLevelCollectionTypedefs {
2251  const char* ScopeIdentifier_Enum(int64_t i) {
2252  switch (i) {
2253  case 0L: return "unknownScope";
2254  case 1L: return "StatementScope";
2255  case 2L: return "SurroundingScope";
2256  case 3L: return "Preamble";
2257  case 4L: return "LAST_SCOPE_TAG";
2258  default: return "";
2259  }
2260  }
2261 
2262  std::string ScopeIdentifier_Enum(int64_t i, const std::string &strip) {
2263  std::string s = ScopeIdentifier_Enum(i);
2264  if (s.empty())
2265  s = "(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
2266  if (boost::starts_with(s, strip))
2267  s = s.substr(strip.size());
2268  return s;
2269  }
2270 
2271  const std::vector<int64_t>& ScopeIdentifier_Enum() {
2272  static const int64_t values[] = {
2273  0L,
2274  1L,
2275  2L,
2276  3L,
2277  4L
2278  };
2279  static const std::vector<int64_t> retval(values, values + 5);
2280  return retval;
2281  }
2282 
2283 }}
2284 
2285 namespace Rose {
2286  std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i, const char *strip, bool canonic) {
2288  if (retval.empty()) {
2289  retval = "(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
2290  } else {
2291  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2292  retval = retval.substr(strlen(strip));
2293  if (canonic)
2294  retval = "MidLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
2295  }
2296  return retval;
2297  }
2298 
2299  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum() {
2301  }
2302 }
2303 
2304 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2305 // /src/midend/astRewriteMechanism/rewrite.h line 66
2306 namespace stringify { namespace MidLevelCollectionTypedefs {
2307  const char* PlacementPosition_Enum(int64_t i) {
2308  switch (i) {
2309  case 0L: return "unknownPositionInScope";
2310  case 1L: return "PreamblePositionInScope";
2311  case 2L: return "TopOfCurrentScope";
2312  case 3L: return "BeforeCurrentPosition";
2313  case 4L: return "ReplaceCurrentPosition";
2314  case 5L: return "AfterCurrentPosition";
2315  case 6L: return "BottomOfCurrentScope";
2316  case 7L: return "LAST_PLACEMENT_TAG";
2317  default: return "";
2318  }
2319  }
2320 
2321  std::string PlacementPosition_Enum(int64_t i, const std::string &strip) {
2322  std::string s = PlacementPosition_Enum(i);
2323  if (s.empty())
2324  s = "(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
2325  if (boost::starts_with(s, strip))
2326  s = s.substr(strip.size());
2327  return s;
2328  }
2329 
2330  const std::vector<int64_t>& PlacementPosition_Enum() {
2331  static const int64_t values[] = {
2332  0L,
2333  1L,
2334  2L,
2335  3L,
2336  4L,
2337  5L,
2338  6L,
2339  7L
2340  };
2341  static const std::vector<int64_t> retval(values, values + 8);
2342  return retval;
2343  }
2344 
2345 }}
2346 
2347 namespace Rose {
2348  std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t i, const char *strip, bool canonic) {
2350  if (retval.empty()) {
2351  retval = "(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
2352  } else {
2353  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2354  retval = retval.substr(strlen(strip));
2355  if (canonic)
2356  retval = "MidLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
2357  }
2358  return retval;
2359  }
2360 
2361  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum() {
2363  }
2364 }
2365 
2366 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2367 // /src/midend/astRewriteMechanism/rewrite.h line 79
2368 namespace stringify { namespace MidLevelCollectionTypedefs {
2369  const char* IntermediateFileStringPosition_Enum(int64_t i) {
2370  switch (i) {
2371  case 0L: return "unknownIntermediatePositionInScope";
2372  case 1L: return "GlobalScopePreamble";
2373  case 2L: return "CurrentLocationTopOfScope";
2374  case 3L: return "CurrentLocationAfter";
2375  case 4L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
2376  case 6L: return "CurrentLocationBottomOfScope";
2377  default: return "";
2378  }
2379  }
2380 
2381  std::string IntermediateFileStringPosition_Enum(int64_t i, const std::string &strip) {
2382  std::string s = IntermediateFileStringPosition_Enum(i);
2383  if (s.empty())
2384  s = "(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
2385  if (boost::starts_with(s, strip))
2386  s = s.substr(strip.size());
2387  return s;
2388  }
2389 
2390  const std::vector<int64_t>& IntermediateFileStringPosition_Enum() {
2391  static const int64_t values[] = {
2392  0L,
2393  1L,
2394  2L,
2395  3L,
2396  4L,
2397  6L
2398  };
2399  static const std::vector<int64_t> retval(values, values + 6);
2400  return retval;
2401  }
2402 
2403 }}
2404 
2405 namespace Rose {
2406  std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i, const char *strip, bool canonic) {
2408  if (retval.empty()) {
2409  retval = "(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
2410  } else {
2411  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2412  retval = retval.substr(strlen(strip));
2413  if (canonic)
2414  retval = "MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
2415  }
2416  return retval;
2417  }
2418 
2419  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
2421  }
2422 }
2423 
2424 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2425 // /src/midend/astRewriteMechanism/rewrite.h line 141
2426 namespace stringify { namespace HighLevelCollectionTypedefs {
2427  const char* ScopeIdentifier_Enum(int64_t i) {
2428  switch (i) {
2429  case 0L: return "unknownScope";
2430  case 1L: return "SurroundingScope";
2431  case 2L: return "ParentScope";
2432  case 3L: return "NestedLoopScope";
2433  case 4L: return "NestedConditionalScope";
2434  case 5L: return "FunctionScope";
2435  case 6L: return "FileScope";
2436  case 7L: return "GlobalScope";
2437  case 8L: return "Preamble";
2438  case 9L: return "LAST_SCOPE_TAG";
2439  default: return "";
2440  }
2441  }
2442 
2443  std::string ScopeIdentifier_Enum(int64_t i, const std::string &strip) {
2444  std::string s = ScopeIdentifier_Enum(i);
2445  if (s.empty())
2446  s = "(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
2447  if (boost::starts_with(s, strip))
2448  s = s.substr(strip.size());
2449  return s;
2450  }
2451 
2452  const std::vector<int64_t>& ScopeIdentifier_Enum() {
2453  static const int64_t values[] = {
2454  0L,
2455  1L,
2456  2L,
2457  3L,
2458  4L,
2459  5L,
2460  6L,
2461  7L,
2462  8L,
2463  9L
2464  };
2465  static const std::vector<int64_t> retval(values, values + 10);
2466  return retval;
2467  }
2468 
2469 }}
2470 
2471 namespace Rose {
2472  std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i, const char *strip, bool canonic) {
2474  if (retval.empty()) {
2475  retval = "(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
2476  } else {
2477  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2478  retval = retval.substr(strlen(strip));
2479  if (canonic)
2480  retval = "HighLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
2481  }
2482  return retval;
2483  }
2484 
2485  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum() {
2487  }
2488 }
2489 
2490 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2491 // /src/midend/astRewriteMechanism/rewrite.h line 162
2492 namespace stringify { namespace HighLevelCollectionTypedefs {
2493  const char* PlacementPosition_Enum(int64_t i) {
2494  switch (i) {
2495  case 0L: return "unknownPositionInScope";
2496  case 1L: return "PreamblePositionInScope";
2497  case 2L: return "TopOfScope";
2498  case 3L: return "TopOfIncludeRegion";
2499  case 4L: return "BottomOfIncludeRegion";
2500  case 5L: return "BeforeCurrentPosition";
2501  case 6L: return "ReplaceCurrentPosition";
2502  case 7L: return "AfterCurrentPosition";
2503  case 8L: return "BottomOfScope";
2504  case 9L: return "LAST_PLACEMENT_TAG";
2505  default: return "";
2506  }
2507  }
2508 
2509  std::string PlacementPosition_Enum(int64_t i, const std::string &strip) {
2510  std::string s = PlacementPosition_Enum(i);
2511  if (s.empty())
2512  s = "(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
2513  if (boost::starts_with(s, strip))
2514  s = s.substr(strip.size());
2515  return s;
2516  }
2517 
2518  const std::vector<int64_t>& PlacementPosition_Enum() {
2519  static const int64_t values[] = {
2520  0L,
2521  1L,
2522  2L,
2523  3L,
2524  4L,
2525  5L,
2526  6L,
2527  7L,
2528  8L,
2529  9L
2530  };
2531  static const std::vector<int64_t> retval(values, values + 10);
2532  return retval;
2533  }
2534 
2535 }}
2536 
2537 namespace Rose {
2538  std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t i, const char *strip, bool canonic) {
2540  if (retval.empty()) {
2541  retval = "(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
2542  } else {
2543  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2544  retval = retval.substr(strlen(strip));
2545  if (canonic)
2546  retval = "HighLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
2547  }
2548  return retval;
2549  }
2550 
2551  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum() {
2553  }
2554 }
2555 
2556 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2557 // /src/midend/astRewriteMechanism/rewrite.h line 176
2558 namespace stringify { namespace HighLevelCollectionTypedefs {
2559  const char* IntermediateFileStringPosition_Enum(int64_t i) {
2560  switch (i) {
2561  case 0L: return "unknownIntermediatePositionInScope";
2562  case 1L: return "GlobalScopePreamble";
2563  case 2L: return "GlobalScopeTopOfScope";
2564  case 3L: return "GlobalScopeTopOfIncludeRegion";
2565  case 4L: return "GlobalScopeBottomOfIncludeRegion";
2566  case 5L: return "GlobalScopeBeforeCurrentPosition";
2567  case 6L: return "GlobalScopeReplaceCurrentPosition";
2568  case 7L: return "FunctionScopePreamble";
2569  case 8L: return "FunctionScopeTopOfScope";
2570  case 9L: return "FunctionScopeBeforeCurrentPosition";
2571  case 10L: return "FunctionScopeReplaceCurrentPosition";
2572  case 11L: return "FunctionScopeAfterCurrentPosition";
2573  case 12L: return "FunctionScopeBottomOfScope";
2574  case 13L: return "GlobalScopeAfterCurrentPosition";
2575  case 14L: return "GlobalScopeBottomOfScope";
2576  case 15L: return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
2577  default: return "";
2578  }
2579  }
2580 
2581  std::string IntermediateFileStringPosition_Enum(int64_t i, const std::string &strip) {
2582  std::string s = IntermediateFileStringPosition_Enum(i);
2583  if (s.empty())
2584  s = "(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
2585  if (boost::starts_with(s, strip))
2586  s = s.substr(strip.size());
2587  return s;
2588  }
2589 
2590  const std::vector<int64_t>& IntermediateFileStringPosition_Enum() {
2591  static const int64_t values[] = {
2592  0L,
2593  1L,
2594  2L,
2595  3L,
2596  4L,
2597  5L,
2598  6L,
2599  7L,
2600  8L,
2601  9L,
2602  10L,
2603  11L,
2604  12L,
2605  13L,
2606  14L,
2607  15L
2608  };
2609  static const std::vector<int64_t> retval(values, values + 16);
2610  return retval;
2611  }
2612 
2613 }}
2614 
2615 namespace Rose {
2616  std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i, const char *strip, bool canonic) {
2618  if (retval.empty()) {
2619  retval = "(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
2620  } else {
2621  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2622  retval = retval.substr(strlen(strip));
2623  if (canonic)
2624  retval = "HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
2625  }
2626  return retval;
2627  }
2628 
2629  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
2631  }
2632 }
2633 
2634 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2635 // /src/midend/astMatching/matcherparser.C line 1846
2636 namespace stringify {
2637  const char* yytokentype(int64_t i) {
2638  switch (i) {
2639  case 258L: return "ALTERNATION";
2640  case 259L: return "NOT";
2641  case 260L: return "AND";
2642  case 261L: return "XOR";
2643  case 262L: return "OR";
2644  case 263L: return "NEQ";
2645  case 264L: return "EQ";
2646  case 265L: return "C_NEQ";
2647  case 266L: return "C_EQ";
2648  case 267L: return "WHERE";
2649  case 268L: return "TRUE";
2650  case 269L: return "FALSE";
2651  case 270L: return "IDENT";
2652  case 271L: return "VARIABLE";
2653  case 272L: return "INTEGER";
2654  case 273L: return "SQ_STRING";
2655  case 274L: return "NULL_NODE";
2656  case 275L: return "DOTDOT";
2657  default: return "";
2658  }
2659  }
2660 
2661  std::string yytokentype(int64_t i, const std::string &strip) {
2662  std::string s = yytokentype(i);
2663  if (s.empty())
2664  s = "(yytokentype)" + boost::lexical_cast<std::string>(i);
2665  if (boost::starts_with(s, strip))
2666  s = s.substr(strip.size());
2667  return s;
2668  }
2669 
2670  const std::vector<int64_t>& yytokentype() {
2671  static const int64_t values[] = {
2672  258L,
2673  259L,
2674  260L,
2675  261L,
2676  262L,
2677  263L,
2678  264L,
2679  265L,
2680  266L,
2681  267L,
2682  268L,
2683  269L,
2684  270L,
2685  271L,
2686  272L,
2687  273L,
2688  274L,
2689  275L
2690  };
2691  static const std::vector<int64_t> retval(values, values + 18);
2692  return retval;
2693  }
2694 
2695 }
2696 
2697 namespace Rose {
2698  std::string stringify_yytokentype(int64_t i, const char *strip, bool canonic) {
2699  std::string retval = stringify::yytokentype(i);
2700  if (retval.empty()) {
2701  retval = "(yytokentype)" + boost::lexical_cast<std::string>(i);
2702  } else {
2703  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2704  retval = retval.substr(strlen(strip));
2705  if (canonic)
2706  retval = "yytokentype::" + retval;
2707  }
2708  return retval;
2709  }
2710 
2711  const std::vector<int64_t>& stringify_yytokentype() {
2712  return stringify::yytokentype();
2713  }
2714 }
2715 
2716 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2717 // /src/midend/astMatching/MatchOperation.h line 42
2718 namespace stringify { namespace MatchStatus {
2719  const char* PatternMatchMode(int64_t i) {
2720  switch (i) {
2721  case 0L: return "MATCHMODE_SHALLOW";
2722  case 1L: return "MATCHMODE_DEEP";
2723  case 2L: return "MATCHMODE_SINGLE";
2724  default: return "";
2725  }
2726  }
2727 
2728  std::string PatternMatchMode(int64_t i, const std::string &strip) {
2729  std::string s = PatternMatchMode(i);
2730  if (s.empty())
2731  s = "(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
2732  if (boost::starts_with(s, strip))
2733  s = s.substr(strip.size());
2734  return s;
2735  }
2736 
2737  const std::vector<int64_t>& PatternMatchMode() {
2738  static const int64_t values[] = {
2739  0L,
2740  1L,
2741  2L
2742  };
2743  static const std::vector<int64_t> retval(values, values + 3);
2744  return retval;
2745  }
2746 
2747 }}
2748 
2749 namespace Rose {
2750  std::string stringifyMatchStatusPatternMatchMode(int64_t i, const char *strip, bool canonic) {
2751  std::string retval = stringify::MatchStatus::PatternMatchMode(i);
2752  if (retval.empty()) {
2753  retval = "(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
2754  } else {
2755  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2756  retval = retval.substr(strlen(strip));
2757  if (canonic)
2758  retval = "MatchStatus::PatternMatchMode::" + retval;
2759  }
2760  return retval;
2761  }
2762 
2763  const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode() {
2765  }
2766 }
2767 
2768 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2769 // /src/midend/astMatching/MatchOperation.h line 43
2770 namespace stringify { namespace MatchStatus {
2771  const char* CheckNodeMode(int64_t i) {
2772  switch (i) {
2773  case 0L: return "NODECHECKMODE_TYPEID";
2774  case 1L: return "NODECHECKMODE_VARIANT";
2775  default: return "";
2776  }
2777  }
2778 
2779  std::string CheckNodeMode(int64_t i, const std::string &strip) {
2780  std::string s = CheckNodeMode(i);
2781  if (s.empty())
2782  s = "(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
2783  if (boost::starts_with(s, strip))
2784  s = s.substr(strip.size());
2785  return s;
2786  }
2787 
2788  const std::vector<int64_t>& CheckNodeMode() {
2789  static const int64_t values[] = {
2790  0L,
2791  1L
2792  };
2793  static const std::vector<int64_t> retval(values, values + 2);
2794  return retval;
2795  }
2796 
2797 }}
2798 
2799 namespace Rose {
2800  std::string stringifyMatchStatusCheckNodeMode(int64_t i, const char *strip, bool canonic) {
2801  std::string retval = stringify::MatchStatus::CheckNodeMode(i);
2802  if (retval.empty()) {
2803  retval = "(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
2804  } else {
2805  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2806  retval = retval.substr(strlen(strip));
2807  if (canonic)
2808  retval = "MatchStatus::CheckNodeMode::" + retval;
2809  }
2810  return retval;
2811  }
2812 
2813  const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode() {
2815  }
2816 }
2817 
2818 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2819 // /src/midend/programTransformation/ompLowering/omp_lowering.h line 37
2820 namespace stringify { namespace OmpSupport {
2821  const char* omp_rtl_enum(int64_t i) {
2822  switch (i) {
2823  case 0L: return "e_gomp";
2824  case 1L: return "e_omni";
2825  case 2L: return "e_last_rtl";
2826  default: return "";
2827  }
2828  }
2829 
2830  std::string omp_rtl_enum(int64_t i, const std::string &strip) {
2831  std::string s = omp_rtl_enum(i);
2832  if (s.empty())
2833  s = "(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
2834  if (boost::starts_with(s, strip))
2835  s = s.substr(strip.size());
2836  return s;
2837  }
2838 
2839  const std::vector<int64_t>& omp_rtl_enum() {
2840  static const int64_t values[] = {
2841  0L,
2842  1L,
2843  2L
2844  };
2845  static const std::vector<int64_t> retval(values, values + 3);
2846  return retval;
2847  }
2848 
2849 }}
2850 
2851 namespace Rose {
2852  std::string stringifyOmpSupport_omp_rtl_enum(int64_t i, const char *strip, bool canonic) {
2853  std::string retval = stringify::OmpSupport::omp_rtl_enum(i);
2854  if (retval.empty()) {
2855  retval = "(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
2856  } else {
2857  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2858  retval = retval.substr(strlen(strip));
2859  if (canonic)
2860  retval = "OmpSupport::omp_rtl_enum::" + retval;
2861  }
2862  return retval;
2863  }
2864 
2865  const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum() {
2867  }
2868 }
2869 
2870 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2871 // /src/midend/programTransformation/ompLowering/xomp.c line 60
2872 namespace stringify {
2873  const char* omp_rtl_enum(int64_t i) {
2874  switch (i) {
2875  case 0L: return "e_undefined";
2876  case 1L: return "e_gomp";
2877  case 2L: return "e_omni";
2878  case 3L: return "e_last_rtl";
2879  default: return "";
2880  }
2881  }
2882 
2883  std::string omp_rtl_enum(int64_t i, const std::string &strip) {
2884  std::string s = omp_rtl_enum(i);
2885  if (s.empty())
2886  s = "(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
2887  if (boost::starts_with(s, strip))
2888  s = s.substr(strip.size());
2889  return s;
2890  }
2891 
2892  const std::vector<int64_t>& omp_rtl_enum() {
2893  static const int64_t values[] = {
2894  0L,
2895  1L,
2896  2L,
2897  3L
2898  };
2899  static const std::vector<int64_t> retval(values, values + 4);
2900  return retval;
2901  }
2902 
2903 }
2904 
2905 namespace Rose {
2906  std::string stringify_omp_rtl_enum(int64_t i, const char *strip, bool canonic) {
2907  std::string retval = stringify::omp_rtl_enum(i);
2908  if (retval.empty()) {
2909  retval = "(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
2910  } else {
2911  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2912  retval = retval.substr(strlen(strip));
2913  if (canonic)
2914  retval = "omp_rtl_enum::" + retval;
2915  }
2916  return retval;
2917  }
2918 
2919  const std::vector<int64_t>& stringify_omp_rtl_enum() {
2920  return stringify::omp_rtl_enum();
2921  }
2922 }
2923 
2924 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2925 // /src/midend/programTransformation/extractFunctionArgumentsNormalization/functionEvaluationOrderTraversal.h line 40
2926 namespace stringify { namespace FunctionCallInfo {
2927  const char* InsertionMode(int64_t i) {
2928  switch (i) {
2929  case 0L: return "INSERT_BEFORE";
2930  case 1L: return "APPEND_SCOPE";
2931  case 2L: return "INVALID";
2932  default: return "";
2933  }
2934  }
2935 
2936  std::string InsertionMode(int64_t i, const std::string &strip) {
2937  std::string s = InsertionMode(i);
2938  if (s.empty())
2939  s = "(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
2940  if (boost::starts_with(s, strip))
2941  s = s.substr(strip.size());
2942  return s;
2943  }
2944 
2945  const std::vector<int64_t>& InsertionMode() {
2946  static const int64_t values[] = {
2947  0L,
2948  1L,
2949  2L
2950  };
2951  static const std::vector<int64_t> retval(values, values + 3);
2952  return retval;
2953  }
2954 
2955 }}
2956 
2957 namespace Rose {
2958  std::string stringifyFunctionCallInfoInsertionMode(int64_t i, const char *strip, bool canonic) {
2959  std::string retval = stringify::FunctionCallInfo::InsertionMode(i);
2960  if (retval.empty()) {
2961  retval = "(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
2962  } else {
2963  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2964  retval = retval.substr(strlen(strip));
2965  if (canonic)
2966  retval = "FunctionCallInfo::InsertionMode::" + retval;
2967  }
2968  return retval;
2969  }
2970 
2971  const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode() {
2973  }
2974 }
2975 
2976 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2977 // /src/midend/programTransformation/implicitCodeGeneration/defaultFunctionGenerator.C line 17
2978 namespace stringify {
2979  const char* defaultEnumFunctionType(int64_t i) {
2980  switch (i) {
2981  case 0L: return "e_unknown";
2982  case 1L: return "e_constructor";
2983  case 2L: return "e_destructor";
2984  case 3L: return "e_copy_constructor";
2985  case 4L: return "e_assignment_operator";
2986  case 5L: return "e_last_type";
2987  default: return "";
2988  }
2989  }
2990 
2991  std::string defaultEnumFunctionType(int64_t i, const std::string &strip) {
2992  std::string s = defaultEnumFunctionType(i);
2993  if (s.empty())
2994  s = "(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
2995  if (boost::starts_with(s, strip))
2996  s = s.substr(strip.size());
2997  return s;
2998  }
2999 
3000  const std::vector<int64_t>& defaultEnumFunctionType() {
3001  static const int64_t values[] = {
3002  0L,
3003  1L,
3004  2L,
3005  3L,
3006  4L,
3007  5L
3008  };
3009  static const std::vector<int64_t> retval(values, values + 6);
3010  return retval;
3011  }
3012 
3013 }
3014 
3015 namespace Rose {
3016  std::string stringify_defaultEnumFunctionType(int64_t i, const char *strip, bool canonic) {
3017  std::string retval = stringify::defaultEnumFunctionType(i);
3018  if (retval.empty()) {
3019  retval = "(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
3020  } else {
3021  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3022  retval = retval.substr(strlen(strip));
3023  if (canonic)
3024  retval = "defaultEnumFunctionType::" + retval;
3025  }
3026  return retval;
3027  }
3028 
3029  const std::vector<int64_t>& stringify_defaultEnumFunctionType() {
3031  }
3032 }
3033 
3034 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3035 // /src/midend/MFB/include/MFB/Sage/graph.hpp line 35
3036 namespace stringify { namespace MFB { namespace Graph { namespace API {
3037  const char* link_kind_e(int64_t i) {
3038  switch (i) {
3039  case 0L: return "e_link_kind_unknown";
3040  case 1L: return "e_link_kind_defines";
3041  case 2L: return "e_link_kind_extends";
3042  case 3L: return "e_link_kind_specializes";
3043  case 4L: return "e_link_kind_represents";
3044  case 5L: return "e_link_kind_param";
3045  case 6L: return "e_link_kind_arg";
3046  case 7L: return "e_link_kind_type_base";
3047  case 8L: return "e_link_kind_last";
3048  default: return "";
3049  }
3050  }
3051 
3052  std::string link_kind_e(int64_t i, const std::string &strip) {
3053  std::string s = link_kind_e(i);
3054  if (s.empty())
3055  s = "(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
3056  if (boost::starts_with(s, strip))
3057  s = s.substr(strip.size());
3058  return s;
3059  }
3060 
3061  const std::vector<int64_t>& link_kind_e() {
3062  static const int64_t values[] = {
3063  0L,
3064  1L,
3065  2L,
3066  3L,
3067  4L,
3068  5L,
3069  6L,
3070  7L,
3071  8L
3072  };
3073  static const std::vector<int64_t> retval(values, values + 9);
3074  return retval;
3075  }
3076 
3077 }}}}
3078 
3079 namespace Rose {
3080  std::string stringifyMFB_GraphAPIlink_kind_e(int64_t i, const char *strip, bool canonic) {
3081  std::string retval = stringify::MFB::Graph::API::link_kind_e(i);
3082  if (retval.empty()) {
3083  retval = "(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
3084  } else {
3085  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3086  retval = retval.substr(strlen(strip));
3087  if (canonic)
3088  retval = "MFB::Graph::API::link_kind_e::" + retval;
3089  }
3090  return retval;
3091  }
3092 
3093  const std::vector<int64_t>& stringifyMFB_GraphAPIlink_kind_e() {
3095  }
3096 }
3097 
3098 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3099 // /src/midend/abstractMemoryObject/memory_object_impl.h line 84
3100 namespace stringify { namespace AbstractMemoryObject { namespace IndexSet {
3101  const char* Index_type(int64_t i) {
3102  switch (i) {
3103  case 0L: return "Integer_type";
3104  case 1L: return "Unknown_type";
3105  default: return "";
3106  }
3107  }
3108 
3109  std::string Index_type(int64_t i, const std::string &strip) {
3110  std::string s = Index_type(i);
3111  if (s.empty())
3112  s = "(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
3113  if (boost::starts_with(s, strip))
3114  s = s.substr(strip.size());
3115  return s;
3116  }
3117 
3118  const std::vector<int64_t>& Index_type() {
3119  static const int64_t values[] = {
3120  0L,
3121  1L
3122  };
3123  static const std::vector<int64_t> retval(values, values + 2);
3124  return retval;
3125  }
3126 
3127 }}}
3128 
3129 namespace Rose {
3130  std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t i, const char *strip, bool canonic) {
3132  if (retval.empty()) {
3133  retval = "(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
3134  } else {
3135  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3136  retval = retval.substr(strlen(strip));
3137  if (canonic)
3138  retval = "AbstractMemoryObject::IndexSet::Index_type::" + retval;
3139  }
3140  return retval;
3141  }
3142 
3143  const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type() {
3145  }
3146 }
3147 
3148 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3149 // /src/midend/MDCG/include/MDCG/Model/base.hpp line 24
3150 namespace stringify { namespace MDCG { namespace Model {
3151  const char* model_elements_e(int64_t i) {
3152  switch (i) {
3153  case 0L: return "e_model_blank";
3154  case 1L: return "e_model_variable";
3155  case 2L: return "e_model_function";
3156  case 3L: return "e_model_field";
3157  case 4L: return "e_model_method";
3158  case 5L: return "e_model_type";
3159  case 6L: return "e_model_class";
3160  case 7L: return "e_model_namespace";
3161  default: return "";
3162  }
3163  }
3164 
3165  std::string model_elements_e(int64_t i, const std::string &strip) {
3166  std::string s = model_elements_e(i);
3167  if (s.empty())
3168  s = "(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
3169  if (boost::starts_with(s, strip))
3170  s = s.substr(strip.size());
3171  return s;
3172  }
3173 
3174  const std::vector<int64_t>& model_elements_e() {
3175  static const int64_t values[] = {
3176  0L,
3177  1L,
3178  2L,
3179  3L,
3180  4L,
3181  5L,
3182  6L,
3183  7L
3184  };
3185  static const std::vector<int64_t> retval(values, values + 8);
3186  return retval;
3187  }
3188 
3189 }}}
3190 
3191 namespace Rose {
3192  std::string stringifyMDCG_Model_model_elements_e(int64_t i, const char *strip, bool canonic) {
3193  std::string retval = stringify::MDCG::Model::model_elements_e(i);
3194  if (retval.empty()) {
3195  retval = "(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
3196  } else {
3197  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3198  retval = retval.substr(strlen(strip));
3199  if (canonic)
3200  retval = "MDCG::Model::model_elements_e::" + retval;
3201  }
3202  return retval;
3203  }
3204 
3205  const std::vector<int64_t>& stringifyMDCG_Model_model_elements_e() {
3207  }
3208 }
3209 
3210 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3211 // /src/midend/MDCG/include/MDCG/Model/base.hpp line 46
3212 namespace stringify { namespace MDCG { namespace Model { namespace element_t {
3213  const char* kind_e(int64_t i) {
3214  switch (i) {
3215  case 0L: return "kind";
3216  default: return "";
3217  }
3218  }
3219 
3220  std::string kind_e(int64_t i, const std::string &strip) {
3221  std::string s = kind_e(i);
3222  if (s.empty())
3223  s = "(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
3224  if (boost::starts_with(s, strip))
3225  s = s.substr(strip.size());
3226  return s;
3227  }
3228 
3229  const std::vector<int64_t>& kind_e() {
3230  static const int64_t values[] = {
3231  0L
3232  };
3233  static const std::vector<int64_t> retval(values, values + 1);
3234  return retval;
3235  }
3236 
3237 }}}}
3238 
3239 namespace Rose {
3240  std::string stringifyMDCG_Model_element_t_kind_e(int64_t i, const char *strip, bool canonic) {
3241  std::string retval = stringify::MDCG::Model::element_t::kind_e(i);
3242  if (retval.empty()) {
3243  retval = "(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
3244  } else {
3245  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3246  retval = retval.substr(strlen(strip));
3247  if (canonic)
3248  retval = "MDCG::Model::element_t::kind_e::" + retval;
3249  }
3250  return retval;
3251  }
3252 
3253  const std::vector<int64_t>& stringifyMDCG_Model_element_t_kind_e() {
3255  }
3256 }
3257 
3258 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3259 // /src/midend/BinaryAnalysis/DwarfLineMapper.h line 18
3260 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace DwarfLineMapper {
3261  const char* Direction(int64_t i) {
3262  switch (i) {
3263  case 1L: return "ADDR2SRC";
3264  case 2L: return "SRC2ADDR";
3265  case 3L: return "BIDIRECTIONAL";
3266  default: return "";
3267  }
3268  }
3269 
3270  std::string Direction(int64_t i, const std::string &strip) {
3271  std::string s = Direction(i);
3272  if (s.empty())
3273  s = "(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
3274  if (boost::starts_with(s, strip))
3275  s = s.substr(strip.size());
3276  return s;
3277  }
3278 
3279  const std::vector<int64_t>& Direction() {
3280  static const int64_t values[] = {
3281  1L,
3282  2L,
3283  3L
3284  };
3285  static const std::vector<int64_t> retval(values, values + 3);
3286  return retval;
3287  }
3288 
3289 }}}}
3290 
3291 namespace Rose {
3292  std::string stringifyBinaryAnalysisDwarfLineMapperDirection(int64_t i, const char *strip, bool canonic) {
3294  if (retval.empty()) {
3295  retval = "(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
3296  } else {
3297  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3298  retval = retval.substr(strlen(strip));
3299  if (canonic)
3300  retval = "Rose::BinaryAnalysis::DwarfLineMapper::Direction::" + retval;
3301  }
3302  return retval;
3303  }
3304 
3305  const std::vector<int64_t>& stringifyBinaryAnalysisDwarfLineMapperDirection() {
3307  }
3308 }
3309 
3310 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3311 // /src/midend/BinaryAnalysis/BinaryMagic.h line 16
3312 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MagicNumber {
3313  const char* Mechanism(int64_t i) {
3314  switch (i) {
3315  case 0L: return "FAST";
3316  case 1L: return "SLOW";
3317  case 2L: return "NONE";
3318  default: return "";
3319  }
3320  }
3321 
3322  std::string Mechanism(int64_t i, const std::string &strip) {
3323  std::string s = Mechanism(i);
3324  if (s.empty())
3325  s = "(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
3326  if (boost::starts_with(s, strip))
3327  s = s.substr(strip.size());
3328  return s;
3329  }
3330 
3331  const std::vector<int64_t>& Mechanism() {
3332  static const int64_t values[] = {
3333  0L,
3334  1L,
3335  2L
3336  };
3337  static const std::vector<int64_t> retval(values, values + 3);
3338  return retval;
3339  }
3340 
3341 }}}}
3342 
3343 namespace Rose {
3344  std::string stringifyBinaryAnalysisMagicNumberMechanism(int64_t i, const char *strip, bool canonic) {
3346  if (retval.empty()) {
3347  retval = "(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
3348  } else {
3349  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3350  retval = retval.substr(strlen(strip));
3351  if (canonic)
3352  retval = "Rose::BinaryAnalysis::MagicNumber::Mechanism::" + retval;
3353  }
3354  return retval;
3355  }
3356 
3357  const std::vector<int64_t>& stringifyBinaryAnalysisMagicNumberMechanism() {
3359  }
3360 }
3361 
3362 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3363 // /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 53
3364 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace TypeStyle {
3365  const char* Flag(int64_t i) {
3366  switch (i) {
3367  case 0L: return "FULL";
3368  case 1L: return "ABBREVIATED";
3369  default: return "";
3370  }
3371  }
3372 
3373  std::string Flag(int64_t i, const std::string &strip) {
3374  std::string s = Flag(i);
3375  if (s.empty())
3376  s = "(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
3377  if (boost::starts_with(s, strip))
3378  s = s.substr(strip.size());
3379  return s;
3380  }
3381 
3382  const std::vector<int64_t>& Flag() {
3383  static const int64_t values[] = {
3384  0L,
3385  1L
3386  };
3387  static const std::vector<int64_t> retval(values, values + 2);
3388  return retval;
3389  }
3390 
3391 }}}}}
3392 
3393 namespace Rose {
3394  std::string stringifyBinaryAnalysisSymbolicExprTypeStyleFlag(int64_t i, const char *strip, bool canonic) {
3396  if (retval.empty()) {
3397  retval = "(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
3398  } else {
3399  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3400  retval = retval.substr(strlen(strip));
3401  if (canonic)
3402  retval = "Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag::" + retval;
3403  }
3404  return retval;
3405  }
3406 
3407  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeStyleFlag() {
3409  }
3410 }
3411 
3412 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3413 // /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 71
3414 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
3415  const char* Operator(int64_t i) {
3416  switch (i) {
3417  case 0L: return "OP_ADD";
3418  case 1L: return "OP_AND";
3419  case 2L: return "OP_ASR";
3420  case 3L: return "OP_CONCAT";
3421  case 4L: return "OP_EQ";
3422  case 5L: return "OP_EXTRACT";
3423  case 6L: return "OP_INVERT";
3424  case 7L: return "OP_ITE";
3425  case 8L: return "OP_LET";
3426  case 9L: return "OP_LSSB";
3427  case 10L: return "OP_MSSB";
3428  case 11L: return "OP_NE";
3429  case 12L: return "OP_NEGATE";
3430  case 13L: return "OP_NOOP";
3431  case 14L: return "OP_OR";
3432  case 15L: return "OP_READ";
3433  case 16L: return "OP_ROL";
3434  case 17L: return "OP_ROR";
3435  case 18L: return "OP_SDIV";
3436  case 19L: return "OP_SET";
3437  case 20L: return "OP_SEXTEND";
3438  case 21L: return "OP_SGE";
3439  case 22L: return "OP_SGT";
3440  case 23L: return "OP_SHL0";
3441  case 24L: return "OP_SHL1";
3442  case 25L: return "OP_SHR0";
3443  case 26L: return "OP_SHR1";
3444  case 27L: return "OP_SLE";
3445  case 28L: return "OP_SLT";
3446  case 29L: return "OP_SMOD";
3447  case 30L: return "OP_SMUL";
3448  case 31L: return "OP_UDIV";
3449  case 32L: return "OP_UEXTEND";
3450  case 33L: return "OP_UGE";
3451  case 34L: return "OP_UGT";
3452  case 35L: return "OP_ULE";
3453  case 36L: return "OP_ULT";
3454  case 37L: return "OP_UMOD";
3455  case 38L: return "OP_UMUL";
3456  case 39L: return "OP_WRITE";
3457  case 40L: return "OP_XOR";
3458  case 41L: return "OP_ZEROP";
3459  case 42L: return "OP_FP_ABS";
3460  case 43L: return "OP_FP_NEGATE";
3461  case 44L: return "OP_FP_ADD";
3462  case 45L: return "OP_FP_MUL";
3463  case 46L: return "OP_FP_DIV";
3464  case 47L: return "OP_FP_MULADD";
3465  case 48L: return "OP_FP_SQRT";
3466  case 49L: return "OP_FP_MOD";
3467  case 50L: return "OP_FP_ROUND";
3468  case 51L: return "OP_FP_MIN";
3469  case 52L: return "OP_FP_MAX";
3470  case 53L: return "OP_FP_LE";
3471  case 54L: return "OP_FP_LT";
3472  case 55L: return "OP_FP_GE";
3473  case 56L: return "OP_FP_GT";
3474  case 57L: return "OP_FP_EQ";
3475  case 58L: return "OP_FP_ISNORM";
3476  case 59L: return "OP_FP_ISSUBNORM";
3477  case 60L: return "OP_FP_ISZERO";
3478  case 61L: return "OP_FP_ISINFINITE";
3479  case 62L: return "OP_FP_ISNAN";
3480  case 63L: return "OP_FP_ISNEG";
3481  case 64L: return "OP_FP_ISPOS";
3482  case 65L: return "OP_CONVERT";
3483  case 66L: return "OP_REINTERPRET";
3484  case 67L: return "OP_NONE";
3485  default: return "";
3486  }
3487  }
3488 
3489  std::string Operator(int64_t i, const std::string &strip) {
3490  std::string s = Operator(i);
3491  if (s.empty())
3492  s = "(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
3493  if (boost::starts_with(s, strip))
3494  s = s.substr(strip.size());
3495  return s;
3496  }
3497 
3498  const std::vector<int64_t>& Operator() {
3499  static const int64_t values[] = {
3500  0L,
3501  1L,
3502  2L,
3503  3L,
3504  4L,
3505  5L,
3506  6L,
3507  7L,
3508  8L,
3509  9L,
3510  10L,
3511  11L,
3512  12L,
3513  13L,
3514  14L,
3515  15L,
3516  16L,
3517  17L,
3518  18L,
3519  19L,
3520  20L,
3521  21L,
3522  22L,
3523  23L,
3524  24L,
3525  25L,
3526  26L,
3527  27L,
3528  28L,
3529  29L,
3530  30L,
3531  31L,
3532  32L,
3533  33L,
3534  34L,
3535  35L,
3536  36L,
3537  37L,
3538  38L,
3539  39L,
3540  40L,
3541  41L,
3542  42L,
3543  43L,
3544  44L,
3545  45L,
3546  46L,
3547  47L,
3548  48L,
3549  49L,
3550  50L,
3551  51L,
3552  52L,
3553  53L,
3554  54L,
3555  55L,
3556  56L,
3557  57L,
3558  58L,
3559  59L,
3560  60L,
3561  61L,
3562  62L,
3563  63L,
3564  64L,
3565  65L,
3566  66L,
3567  67L
3568  };
3569  static const std::vector<int64_t> retval(values, values + 68);
3570  return retval;
3571  }
3572 
3573 }}}}
3574 
3575 namespace Rose {
3576  std::string stringifyBinaryAnalysisSymbolicExprOperator(int64_t i, const char *strip, bool canonic) {
3578  if (retval.empty()) {
3579  retval = "(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
3580  } else {
3581  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3582  retval = retval.substr(strlen(strip));
3583  if (canonic)
3584  retval = "Rose::BinaryAnalysis::SymbolicExpr::Operator::" + retval;
3585  }
3586  return retval;
3587  }
3588 
3589  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprOperator() {
3591  }
3592 }
3593 
3594 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3595 // /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 173
3596 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Formatter {
3597  const char* ShowComments(int64_t i) {
3598  switch (i) {
3599  case 0L: return "CMT_SILENT";
3600  case 1L: return "CMT_AFTER";
3601  case 2L: return "CMT_INSTEAD";
3602  default: return "";
3603  }
3604  }
3605 
3606  std::string ShowComments(int64_t i, const std::string &strip) {
3607  std::string s = ShowComments(i);
3608  if (s.empty())
3609  s = "(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
3610  if (boost::starts_with(s, strip))
3611  s = s.substr(strip.size());
3612  return s;
3613  }
3614 
3615  const std::vector<int64_t>& ShowComments() {
3616  static const int64_t values[] = {
3617  0L,
3618  1L,
3619  2L
3620  };
3621  static const std::vector<int64_t> retval(values, values + 3);
3622  return retval;
3623  }
3624 
3625 }}}}}
3626 
3627 namespace Rose {
3628  std::string stringifyBinaryAnalysisSymbolicExprFormatterShowComments(int64_t i, const char *strip, bool canonic) {
3630  if (retval.empty()) {
3631  retval = "(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
3632  } else {
3633  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3634  retval = retval.substr(strlen(strip));
3635  if (canonic)
3636  retval = "Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments::" + retval;
3637  }
3638  return retval;
3639  }
3640 
3641  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprFormatterShowComments() {
3643  }
3644 }
3645 
3646 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3647 // /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 193
3648 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr {
3649  const char* VisitAction(int64_t i) {
3650  switch (i) {
3651  case 0L: return "CONTINUE";
3652  case 1L: return "TRUNCATE";
3653  case 2L: return "TERMINATE";
3654  default: return "";
3655  }
3656  }
3657 
3658  std::string VisitAction(int64_t i, const std::string &strip) {
3659  std::string s = VisitAction(i);
3660  if (s.empty())
3661  s = "(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
3662  if (boost::starts_with(s, strip))
3663  s = s.substr(strip.size());
3664  return s;
3665  }
3666 
3667  const std::vector<int64_t>& VisitAction() {
3668  static const int64_t values[] = {
3669  0L,
3670  1L,
3671  2L
3672  };
3673  static const std::vector<int64_t> retval(values, values + 3);
3674  return retval;
3675  }
3676 
3677 }}}}
3678 
3679 namespace Rose {
3680  std::string stringifyBinaryAnalysisSymbolicExprVisitAction(int64_t i, const char *strip, bool canonic) {
3682  if (retval.empty()) {
3683  retval = "(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
3684  } else {
3685  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3686  retval = retval.substr(strlen(strip));
3687  if (canonic)
3688  retval = "Rose::BinaryAnalysis::SymbolicExpr::VisitAction::" + retval;
3689  }
3690  return retval;
3691  }
3692 
3693  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprVisitAction() {
3695  }
3696 }
3697 
3698 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3699 // /src/midend/BinaryAnalysis/BinarySymbolicExpr.h line 226
3700 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpr { namespace Type {
3701  const char* TypeClass(int64_t i) {
3702  switch (i) {
3703  case 0L: return "INTEGER";
3704  case 1L: return "FP";
3705  case 2L: return "MEMORY";
3706  case 3L: return "INVALID";
3707  default: return "";
3708  }
3709  }
3710 
3711  std::string TypeClass(int64_t i, const std::string &strip) {
3712  std::string s = TypeClass(i);
3713  if (s.empty())
3714  s = "(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
3715  if (boost::starts_with(s, strip))
3716  s = s.substr(strip.size());
3717  return s;
3718  }
3719 
3720  const std::vector<int64_t>& TypeClass() {
3721  static const int64_t values[] = {
3722  0L,
3723  1L,
3724  2L,
3725  3L
3726  };
3727  static const std::vector<int64_t> retval(values, values + 4);
3728  return retval;
3729  }
3730 
3731 }}}}}
3732 
3733 namespace Rose {
3734  std::string stringifyBinaryAnalysisSymbolicExprTypeTypeClass(int64_t i, const char *strip, bool canonic) {
3736  if (retval.empty()) {
3737  retval = "(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
3738  } else {
3739  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3740  retval = retval.substr(strlen(strip));
3741  if (canonic)
3742  retval = "Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass::" + retval;
3743  }
3744  return retval;
3745  }
3746 
3747  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeTypeClass() {
3749  }
3750 }
3751 
3752 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3753 // /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 50
3754 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
3755  const char* StackParameterOrder(int64_t i) {
3756  switch (i) {
3757  case 0L: return "LEFT_TO_RIGHT";
3758  case 1L: return "RIGHT_TO_LEFT";
3759  case 2L: return "ORDER_UNSPECIFIED";
3760  default: return "";
3761  }
3762  }
3763 
3764  std::string StackParameterOrder(int64_t i, const std::string &strip) {
3765  std::string s = StackParameterOrder(i);
3766  if (s.empty())
3767  s = "(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
3768  if (boost::starts_with(s, strip))
3769  s = s.substr(strip.size());
3770  return s;
3771  }
3772 
3773  const std::vector<int64_t>& StackParameterOrder() {
3774  static const int64_t values[] = {
3775  0L,
3776  1L,
3777  2L
3778  };
3779  static const std::vector<int64_t> retval(values, values + 3);
3780  return retval;
3781  }
3782 
3783 }}}}
3784 
3785 namespace Rose {
3786  std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(int64_t i, const char *strip, bool canonic) {
3788  if (retval.empty()) {
3789  retval = "(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
3790  } else {
3791  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3792  retval = retval.substr(strlen(strip));
3793  if (canonic)
3794  retval = "Rose::BinaryAnalysis::CallingConvention::StackParameterOrder::" + retval;
3795  }
3796  return retval;
3797  }
3798 
3799  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackParameterOrder() {
3801  }
3802 }
3803 
3804 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3805 // /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 57
3806 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
3807  const char* StackDirection(int64_t i) {
3808  switch (i) {
3809  case 0L: return "GROWS_UP";
3810  case 1L: return "GROWS_DOWN";
3811  default: return "";
3812  }
3813  }
3814 
3815  std::string StackDirection(int64_t i, const std::string &strip) {
3816  std::string s = StackDirection(i);
3817  if (s.empty())
3818  s = "(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
3819  if (boost::starts_with(s, strip))
3820  s = s.substr(strip.size());
3821  return s;
3822  }
3823 
3824  const std::vector<int64_t>& StackDirection() {
3825  static const int64_t values[] = {
3826  0L,
3827  1L
3828  };
3829  static const std::vector<int64_t> retval(values, values + 2);
3830  return retval;
3831  }
3832 
3833 }}}}
3834 
3835 namespace Rose {
3836  std::string stringifyBinaryAnalysisCallingConventionStackDirection(int64_t i, const char *strip, bool canonic) {
3838  if (retval.empty()) {
3839  retval = "(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
3840  } else {
3841  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3842  retval = retval.substr(strlen(strip));
3843  if (canonic)
3844  retval = "Rose::BinaryAnalysis::CallingConvention::StackDirection::" + retval;
3845  }
3846  return retval;
3847  }
3848 
3849  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackDirection() {
3851  }
3852 }
3853 
3854 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3855 // /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 63
3856 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
3857  const char* StackCleanup(int64_t i) {
3858  switch (i) {
3859  case 0L: return "CLEANUP_BY_CALLER";
3860  case 1L: return "CLEANUP_BY_CALLEE";
3861  case 2L: return "CLEANUP_UNSPECIFIED";
3862  default: return "";
3863  }
3864  }
3865 
3866  std::string StackCleanup(int64_t i, const std::string &strip) {
3867  std::string s = StackCleanup(i);
3868  if (s.empty())
3869  s = "(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
3870  if (boost::starts_with(s, strip))
3871  s = s.substr(strip.size());
3872  return s;
3873  }
3874 
3875  const std::vector<int64_t>& StackCleanup() {
3876  static const int64_t values[] = {
3877  0L,
3878  1L,
3879  2L
3880  };
3881  static const std::vector<int64_t> retval(values, values + 3);
3882  return retval;
3883  }
3884 
3885 }}}}
3886 
3887 namespace Rose {
3888  std::string stringifyBinaryAnalysisCallingConventionStackCleanup(int64_t i, const char *strip, bool canonic) {
3890  if (retval.empty()) {
3891  retval = "(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
3892  } else {
3893  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3894  retval = retval.substr(strlen(strip));
3895  if (canonic)
3896  retval = "Rose::BinaryAnalysis::CallingConvention::StackCleanup::" + retval;
3897  }
3898  return retval;
3899  }
3900 
3901  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackCleanup() {
3903  }
3904 }
3905 
3906 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3907 // /src/midend/BinaryAnalysis/BinaryCallingConvention.h line 87
3908 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention { namespace ParameterLocation {
3909  const char* Type(int64_t i) {
3910  switch (i) {
3911  case 0L: return "NO_LOCATION";
3912  case 1L: return "REGISTER";
3913  case 2L: return "STACK";
3914  case 3L: return "ABSOLUTE";
3915  default: return "";
3916  }
3917  }
3918 
3919  std::string Type(int64_t i, const std::string &strip) {
3920  std::string s = Type(i);
3921  if (s.empty())
3922  s = "(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
3923  if (boost::starts_with(s, strip))
3924  s = s.substr(strip.size());
3925  return s;
3926  }
3927 
3928  const std::vector<int64_t>& Type() {
3929  static const int64_t values[] = {
3930  0L,
3931  1L,
3932  2L,
3933  3L
3934  };
3935  static const std::vector<int64_t> retval(values, values + 4);
3936  return retval;
3937  }
3938 
3939 }}}}}
3940 
3941 namespace Rose {
3942  std::string stringifyBinaryAnalysisCallingConventionParameterLocationType(int64_t i, const char *strip, bool canonic) {
3944  if (retval.empty()) {
3945  retval = "(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
3946  } else {
3947  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3948  retval = retval.substr(strlen(strip));
3949  if (canonic)
3950  retval = "Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type::" + retval;
3951  }
3952  return retval;
3953  }
3954 
3955  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionParameterLocationType() {
3957  }
3958 }
3959 
3960 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3961 // /src/midend/BinaryAnalysis/BinaryConcolic.h line 99
3962 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace Update {
3963  const char* Flag(int64_t i) {
3964  switch (i) {
3965  case 0L: return "NO";
3966  case 1L: return "YES";
3967  default: return "";
3968  }
3969  }
3970 
3971  std::string Flag(int64_t i, const std::string &strip) {
3972  std::string s = Flag(i);
3973  if (s.empty())
3974  s = "(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
3975  if (boost::starts_with(s, strip))
3976  s = s.substr(strip.size());
3977  return s;
3978  }
3979 
3980  const std::vector<int64_t>& Flag() {
3981  static const int64_t values[] = {
3982  0L,
3983  1L
3984  };
3985  static const std::vector<int64_t> retval(values, values + 2);
3986  return retval;
3987  }
3988 
3989 }}}}}
3990 
3991 namespace Rose {
3992  std::string stringifyBinaryAnalysisConcolicUpdateFlag(int64_t i, const char *strip, bool canonic) {
3994  if (retval.empty()) {
3995  retval = "(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
3996  } else {
3997  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3998  retval = retval.substr(strlen(strip));
3999  if (canonic)
4000  retval = "Rose::BinaryAnalysis::Concolic::Update::Flag::" + retval;
4001  }
4002  return retval;
4003  }
4004 
4005  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdateFlag() {
4007  }
4008 }
4009 
4010 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4011 // /src/midend/BinaryAnalysis/BinaryReachability.h line 23
4012 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability {
4013  const char* Reason(int64_t i) {
4014  switch (i) {
4015  case 0L: return "NOT_REACHABLE";
4016  case 1L: return "PROGRAM_ENTRY_POINT";
4017  case 2L: return "EXPORTED_FUNCTION";
4018  case 4L: return "SIGNAL_HANDLER";
4019  case 128L: return "ASSUMED";
4020  case 256L: return "EXPLICIT_MEM_CONSTANT";
4021  case 512L: return "EXPLICIT_INSN_CONSTANT";
4022  case 1024L: return "IMPLICIT_FUNC_CONSTANT";
4023  case 65536L: return "USER_DEFINED_0";
4024  case 131072L: return "USER_DEFINED_1";
4025  case 262144L: return "USER_DEFINED_2";
4026  case 524288L: return "USER_DEFINED_3";
4027  case 1048576L: return "USER_DEFINED_4";
4028  case 2097152L: return "USER_DEFINED_5";
4029  case 4194304L: return "USER_DEFINED_6";
4030  case 8388608L: return "USER_DEFINED_7";
4031  case 16777216L: return "USER_DEFINED_8";
4032  case 33554432L: return "USER_DEFINED_9";
4033  case 67108864L: return "USER_DEFINED_10";
4034  case 134217728L: return "USER_DEFINED_11";
4035  case 268435456L: return "USER_DEFINED_12";
4036  case 536870912L: return "USER_DEFINED_13";
4037  case 1073741824L: return "USER_DEFINED_14";
4038  case 2147483648L: return "USER_DEFINED_15";
4039  default: return "";
4040  }
4041  }
4042 
4043  std::string Reason(int64_t i, const std::string &strip) {
4044  std::string s = Reason(i);
4045  if (s.empty())
4046  s = "(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
4047  if (boost::starts_with(s, strip))
4048  s = s.substr(strip.size());
4049  return s;
4050  }
4051 
4052  const std::vector<int64_t>& Reason() {
4053  static const int64_t values[] = {
4054  0L,
4055  1L,
4056  2L,
4057  4L,
4058  128L,
4059  256L,
4060  512L,
4061  1024L,
4062  65536L,
4063  131072L,
4064  262144L,
4065  524288L,
4066  1048576L,
4067  2097152L,
4068  4194304L,
4069  8388608L,
4070  16777216L,
4071  33554432L,
4072  67108864L,
4073  134217728L,
4074  268435456L,
4075  536870912L,
4076  1073741824L,
4077  2147483648L
4078  };
4079  static const std::vector<int64_t> retval(values, values + 24);
4080  return retval;
4081  }
4082 
4083 }}}}
4084 
4085 namespace Rose {
4086  std::string stringifyBinaryAnalysisReachabilityReason(int64_t i, const char *strip, bool canonic) {
4088  if (retval.empty()) {
4089  retval = "(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
4090  } else {
4091  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4092  retval = retval.substr(strlen(strip));
4093  if (canonic)
4094  retval = "Rose::BinaryAnalysis::Reachability::Reason::" + retval;
4095  }
4096  return retval;
4097  }
4098 
4099  const std::vector<int64_t>& stringifyBinaryAnalysisReachabilityReason() {
4101  }
4102 }
4103 
4104 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4105 // /src/midend/BinaryAnalysis/BinarySymbolicExprParser.h line 55
4106 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExprParser { namespace Token {
4107  const char* Type(int64_t i) {
4108  switch (i) {
4109  case 0L: return "NONE";
4110  case 1L: return "LTPAREN";
4111  case 2L: return "RTPAREN";
4112  case 3L: return "BITVECTOR";
4113  case 4L: return "SYMBOL";
4114  default: return "";
4115  }
4116  }
4117 
4118  std::string Type(int64_t i, const std::string &strip) {
4119  std::string s = Type(i);
4120  if (s.empty())
4121  s = "(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
4122  if (boost::starts_with(s, strip))
4123  s = s.substr(strip.size());
4124  return s;
4125  }
4126 
4127  const std::vector<int64_t>& Type() {
4128  static const int64_t values[] = {
4129  0L,
4130  1L,
4131  2L,
4132  3L,
4133  4L
4134  };
4135  static const std::vector<int64_t> retval(values, values + 5);
4136  return retval;
4137  }
4138 
4139 }}}}}
4140 
4141 namespace Rose {
4142  std::string stringifyBinaryAnalysisSymbolicExprParserTokenType(int64_t i, const char *strip, bool canonic) {
4144  if (retval.empty()) {
4145  retval = "(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
4146  } else {
4147  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4148  retval = retval.substr(strlen(strip));
4149  if (canonic)
4150  retval = "Rose::BinaryAnalysis::SymbolicExprParser::Token::Type::" + retval;
4151  }
4152  return retval;
4153  }
4154 
4155  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprParserTokenType() {
4157  }
4158 }
4159 
4160 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4161 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 33
4162 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
4163  const char* SearchMode(int64_t i) {
4164  switch (i) {
4165  case 0L: return "SEARCH_SINGLE_DFS";
4166  case 1L: return "SEARCH_SINGLE_BFS";
4167  case 2L: return "SEARCH_MULTI";
4168  default: return "";
4169  }
4170  }
4171 
4172  std::string SearchMode(int64_t i, const std::string &strip) {
4173  std::string s = SearchMode(i);
4174  if (s.empty())
4175  s = "(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
4176  if (boost::starts_with(s, strip))
4177  s = s.substr(strip.size());
4178  return s;
4179  }
4180 
4181  const std::vector<int64_t>& SearchMode() {
4182  static const int64_t values[] = {
4183  0L,
4184  1L,
4185  2L
4186  };
4187  static const std::vector<int64_t> retval(values, values + 3);
4188  return retval;
4189  }
4190 
4191 }}}}
4192 
4193 namespace Rose {
4194  std::string stringifyBinaryAnalysisFeasiblePathSearchMode(int64_t i, const char *strip, bool canonic) {
4196  if (retval.empty()) {
4197  retval = "(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
4198  } else {
4199  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4200  retval = retval.substr(strlen(strip));
4201  if (canonic)
4202  retval = "Rose::BinaryAnalysis::FeasiblePath::SearchMode::" + retval;
4203  }
4204  return retval;
4205  }
4206 
4207  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSearchMode() {
4209  }
4210 }
4211 
4212 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4213 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 40
4214 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
4215  const char* SemanticMemoryParadigm(int64_t i) {
4216  switch (i) {
4217  case 0L: return "LIST_BASED_MEMORY";
4218  case 1L: return "MAP_BASED_MEMORY";
4219  default: return "";
4220  }
4221  }
4222 
4223  std::string SemanticMemoryParadigm(int64_t i, const std::string &strip) {
4224  std::string s = SemanticMemoryParadigm(i);
4225  if (s.empty())
4226  s = "(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
4227  if (boost::starts_with(s, strip))
4228  s = s.substr(strip.size());
4229  return s;
4230  }
4231 
4232  const std::vector<int64_t>& SemanticMemoryParadigm() {
4233  static const int64_t values[] = {
4234  0L,
4235  1L
4236  };
4237  static const std::vector<int64_t> retval(values, values + 2);
4238  return retval;
4239  }
4240 
4241 }}}}
4242 
4243 namespace Rose {
4244  std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(int64_t i, const char *strip, bool canonic) {
4246  if (retval.empty()) {
4247  retval = "(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
4248  } else {
4249  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4250  retval = retval.substr(strlen(strip));
4251  if (canonic)
4252  retval = "Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm::" + retval;
4253  }
4254  return retval;
4255  }
4256 
4257  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm() {
4259  }
4260 }
4261 
4262 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4263 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 46
4264 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
4265  const char* EdgeVisitOrder(int64_t i) {
4266  switch (i) {
4267  case 0L: return "VISIT_NATURAL";
4268  case 1L: return "VISIT_REVERSE";
4269  case 2L: return "VISIT_RANDOM";
4270  default: return "";
4271  }
4272  }
4273 
4274  std::string EdgeVisitOrder(int64_t i, const std::string &strip) {
4275  std::string s = EdgeVisitOrder(i);
4276  if (s.empty())
4277  s = "(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
4278  if (boost::starts_with(s, strip))
4279  s = s.substr(strip.size());
4280  return s;
4281  }
4282 
4283  const std::vector<int64_t>& EdgeVisitOrder() {
4284  static const int64_t values[] = {
4285  0L,
4286  1L,
4287  2L
4288  };
4289  static const std::vector<int64_t> retval(values, values + 3);
4290  return retval;
4291  }
4292 
4293 }}}}
4294 
4295 namespace Rose {
4296  std::string stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder(int64_t i, const char *strip, bool canonic) {
4298  if (retval.empty()) {
4299  retval = "(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
4300  } else {
4301  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4302  retval = retval.substr(strlen(strip));
4303  if (canonic)
4304  retval = "Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder::" + retval;
4305  }
4306  return retval;
4307  }
4308 
4309  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder() {
4311  }
4312 }
4313 
4314 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4315 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 53
4316 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
4317  const char* IoMode(int64_t i) {
4318  switch (i) {
4319  case 0L: return "READ";
4320  case 1L: return "WRITE";
4321  default: return "";
4322  }
4323  }
4324 
4325  std::string IoMode(int64_t i, const std::string &strip) {
4326  std::string s = IoMode(i);
4327  if (s.empty())
4328  s = "(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
4329  if (boost::starts_with(s, strip))
4330  s = s.substr(strip.size());
4331  return s;
4332  }
4333 
4334  const std::vector<int64_t>& IoMode() {
4335  static const int64_t values[] = {
4336  0L,
4337  1L
4338  };
4339  static const std::vector<int64_t> retval(values, values + 2);
4340  return retval;
4341  }
4342 
4343 }}}}
4344 
4345 namespace Rose {
4346  std::string stringifyBinaryAnalysisFeasiblePathIoMode(int64_t i, const char *strip, bool canonic) {
4348  if (retval.empty()) {
4349  retval = "(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
4350  } else {
4351  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4352  retval = retval.substr(strlen(strip));
4353  if (canonic)
4354  retval = "Rose::BinaryAnalysis::FeasiblePath::IoMode::" + retval;
4355  }
4356  return retval;
4357  }
4358 
4359  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathIoMode() {
4361  }
4362 }
4363 
4364 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4365 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 56
4366 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
4367  const char* MayOrMust(int64_t i) {
4368  switch (i) {
4369  case 0L: return "MAY";
4370  case 1L: return "MUST";
4371  default: return "";
4372  }
4373  }
4374 
4375  std::string MayOrMust(int64_t i, const std::string &strip) {
4376  std::string s = MayOrMust(i);
4377  if (s.empty())
4378  s = "(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
4379  if (boost::starts_with(s, strip))
4380  s = s.substr(strip.size());
4381  return s;
4382  }
4383 
4384  const std::vector<int64_t>& MayOrMust() {
4385  static const int64_t values[] = {
4386  0L,
4387  1L
4388  };
4389  static const std::vector<int64_t> retval(values, values + 2);
4390  return retval;
4391  }
4392 
4393 }}}}
4394 
4395 namespace Rose {
4396  std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(int64_t i, const char *strip, bool canonic) {
4398  if (retval.empty()) {
4399  retval = "(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
4400  } else {
4401  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4402  retval = retval.substr(strlen(strip));
4403  if (canonic)
4404  retval = "Rose::BinaryAnalysis::FeasiblePath::MayOrMust::" + retval;
4405  }
4406  return retval;
4407  }
4408 
4409  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathMayOrMust() {
4411  }
4412 }
4413 
4414 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4415 // /src/midend/BinaryAnalysis/BinaryFeasiblePath.h line 156
4416 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath { namespace PathProcessor {
4417  const char* Action(int64_t i) {
4418  switch (i) {
4419  case 0L: return "BREAK";
4420  case 1L: return "CONTINUE";
4421  default: return "";
4422  }
4423  }
4424 
4425  std::string Action(int64_t i, const std::string &strip) {
4426  std::string s = Action(i);
4427  if (s.empty())
4428  s = "(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
4429  if (boost::starts_with(s, strip))
4430  s = s.substr(strip.size());
4431  return s;
4432  }
4433 
4434  const std::vector<int64_t>& Action() {
4435  static const int64_t values[] = {
4436  0L,
4437  1L
4438  };
4439  static const std::vector<int64_t> retval(values, values + 2);
4440  return retval;
4441  }
4442 
4443 }}}}}
4444 
4445 namespace Rose {
4446  std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(int64_t i, const char *strip, bool canonic) {
4448  if (retval.empty()) {
4449  retval = "(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
4450  } else {
4451  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4452  retval = retval.substr(strlen(strip));
4453  if (canonic)
4454  retval = "Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action::" + retval;
4455  }
4456  return retval;
4457  }
4458 
4459  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathPathProcessorAction() {
4461  }
4462 }
4463 
4464 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4465 // /src/midend/BinaryAnalysis/BinaryDebugger.h line 28
4466 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
4467  const char* DetachMode(int64_t i) {
4468  switch (i) {
4469  case 0L: return "KILL";
4470  case 1L: return "DETACH";
4471  case 2L: return "CONTINUE";
4472  case 3L: return "NOTHING";
4473  default: return "";
4474  }
4475  }
4476 
4477  std::string DetachMode(int64_t i, const std::string &strip) {
4478  std::string s = DetachMode(i);
4479  if (s.empty())
4480  s = "(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
4481  if (boost::starts_with(s, strip))
4482  s = s.substr(strip.size());
4483  return s;
4484  }
4485 
4486  const std::vector<int64_t>& DetachMode() {
4487  static const int64_t values[] = {
4488  0L,
4489  1L,
4490  2L,
4491  3L
4492  };
4493  static const std::vector<int64_t> retval(values, values + 4);
4494  return retval;
4495  }
4496 
4497 }}}}
4498 
4499 namespace Rose {
4500  std::string stringifyBinaryAnalysisDebuggerDetachMode(int64_t i, const char *strip, bool canonic) {
4502  if (retval.empty()) {
4503  retval = "(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
4504  } else {
4505  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4506  retval = retval.substr(strlen(strip));
4507  if (canonic)
4508  retval = "Rose::BinaryAnalysis::Debugger::DetachMode::" + retval;
4509  }
4510  return retval;
4511  }
4512 
4513  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerDetachMode() {
4515  }
4516 }
4517 
4518 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4519 // /src/midend/BinaryAnalysis/BinaryDebugger.h line 36
4520 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
4521  const char* Flag(int64_t i) {
4522  switch (i) {
4523  case 1L: return "ATTACH";
4524  case 2L: return "REDIRECT_INPUT";
4525  case 4L: return "REDIRECT_OUTPUT";
4526  case 8L: return "REDIRECT_ERROR";
4527  case 16L: return "CLOSE_FILES";
4528  case 19L: return "DEFAULT_FLAGS";
4529  default: return "";
4530  }
4531  }
4532 
4533  std::string Flag(int64_t i, const std::string &strip) {
4534  std::string s = Flag(i);
4535  if (s.empty())
4536  s = "(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
4537  if (boost::starts_with(s, strip))
4538  s = s.substr(strip.size());
4539  return s;
4540  }
4541 
4542  const std::vector<int64_t>& Flag() {
4543  static const int64_t values[] = {
4544  1L,
4545  2L,
4546  4L,
4547  8L,
4548  16L,
4549  19L
4550  };
4551  static const std::vector<int64_t> retval(values, values + 6);
4552  return retval;
4553  }
4554 
4555 }}}}
4556 
4557 namespace Rose {
4558  std::string stringifyBinaryAnalysisDebuggerFlag(int64_t i, const char *strip, bool canonic) {
4559  std::string retval = stringify::Rose::BinaryAnalysis::Debugger::Flag(i);
4560  if (retval.empty()) {
4561  retval = "(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
4562  } else {
4563  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4564  retval = retval.substr(strlen(strip));
4565  if (canonic)
4566  retval = "Rose::BinaryAnalysis::Debugger::Flag::" + retval;
4567  }
4568  return retval;
4569  }
4570 
4571  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFlag() {
4573  }
4574 }
4575 
4576 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4577 // /src/midend/BinaryAnalysis/BinaryDebugger.h line 192
4578 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
4579  const char* RegPageStatus(int64_t i) {
4580  switch (i) {
4581  case 0L: return "REGPAGE_NONE";
4582  case 1L: return "REGPAGE_REGS";
4583  case 2L: return "REGPAGE_FPREGS";
4584  default: return "";
4585  }
4586  }
4587 
4588  std::string RegPageStatus(int64_t i, const std::string &strip) {
4589  std::string s = RegPageStatus(i);
4590  if (s.empty())
4591  s = "(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
4592  if (boost::starts_with(s, strip))
4593  s = s.substr(strip.size());
4594  return s;
4595  }
4596 
4597  const std::vector<int64_t>& RegPageStatus() {
4598  static const int64_t values[] = {
4599  0L,
4600  1L,
4601  2L
4602  };
4603  static const std::vector<int64_t> retval(values, values + 3);
4604  return retval;
4605  }
4606 
4607 }}}}
4608 
4609 namespace Rose {
4610  std::string stringifyBinaryAnalysisDebuggerRegPageStatus(int64_t i, const char *strip, bool canonic) {
4612  if (retval.empty()) {
4613  retval = "(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
4614  } else {
4615  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4616  retval = retval.substr(strlen(strip));
4617  if (canonic)
4618  retval = "Rose::BinaryAnalysis::Debugger::RegPageStatus::" + retval;
4619  }
4620  return retval;
4621  }
4622 
4623  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerRegPageStatus() {
4625  }
4626 }
4627 
4628 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4629 // /src/midend/BinaryAnalysis/BinaryDebugger.h line 305
4630 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
4631  const char* FilterActionFlags(int64_t i) {
4632  switch (i) {
4633  case 1L: return "REJECT";
4634  case 2L: return "STOP";
4635  default: return "";
4636  }
4637  }
4638 
4639  std::string FilterActionFlags(int64_t i, const std::string &strip) {
4640  std::string s = FilterActionFlags(i);
4641  if (s.empty())
4642  s = "(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
4643  if (boost::starts_with(s, strip))
4644  s = s.substr(strip.size());
4645  return s;
4646  }
4647 
4648  const std::vector<int64_t>& FilterActionFlags() {
4649  static const int64_t values[] = {
4650  1L,
4651  2L
4652  };
4653  static const std::vector<int64_t> retval(values, values + 2);
4654  return retval;
4655  }
4656 
4657 }}}}
4658 
4659 namespace Rose {
4660  std::string stringifyBinaryAnalysisDebuggerFilterActionFlags(int64_t i, const char *strip, bool canonic) {
4662  if (retval.empty()) {
4663  retval = "(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
4664  } else {
4665  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4666  retval = retval.substr(strlen(strip));
4667  if (canonic)
4668  retval = "Rose::BinaryAnalysis::Debugger::FilterActionFlags::" + retval;
4669  }
4670  return retval;
4671  }
4672 
4673  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFilterActionFlags() {
4675  }
4676 }
4677 
4678 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4679 // /src/midend/BinaryAnalysis/BinarySmtSolver.h line 42
4680 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
4681  const char* LinkMode(int64_t i) {
4682  switch (i) {
4683  case 0L: return "LM_NONE";
4684  case 1L: return "LM_LIBRARY";
4685  case 2L: return "LM_EXECUTABLE";
4686  case 3L: return "LM_ANY";
4687  default: return "";
4688  }
4689  }
4690 
4691  std::string LinkMode(int64_t i, const std::string &strip) {
4692  std::string s = LinkMode(i);
4693  if (s.empty())
4694  s = "(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
4695  if (boost::starts_with(s, strip))
4696  s = s.substr(strip.size());
4697  return s;
4698  }
4699 
4700  const std::vector<int64_t>& LinkMode() {
4701  static const int64_t values[] = {
4702  0L,
4703  1L,
4704  2L,
4705  3L
4706  };
4707  static const std::vector<int64_t> retval(values, values + 4);
4708  return retval;
4709  }
4710 
4711 }}}}
4712 
4713 namespace Rose {
4714  std::string stringifyBinaryAnalysisSmtSolverLinkMode(int64_t i, const char *strip, bool canonic) {
4716  if (retval.empty()) {
4717  retval = "(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
4718  } else {
4719  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4720  retval = retval.substr(strlen(strip));
4721  if (canonic)
4722  retval = "Rose::BinaryAnalysis::SmtSolver::LinkMode::" + retval;
4723  }
4724  return retval;
4725  }
4726 
4727  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverLinkMode() {
4729  }
4730 }
4731 
4732 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4733 // /src/midend/BinaryAnalysis/BinarySmtSolver.h line 54
4734 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
4735  const char* Type(int64_t i) {
4736  switch (i) {
4737  case 0L: return "NO_TYPE";
4738  case 1L: return "BOOLEAN";
4739  case 2L: return "BIT_VECTOR";
4740  case 3L: return "MEM_STATE";
4741  default: return "";
4742  }
4743  }
4744 
4745  std::string Type(int64_t i, const std::string &strip) {
4746  std::string s = Type(i);
4747  if (s.empty())
4748  s = "(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
4749  if (boost::starts_with(s, strip))
4750  s = s.substr(strip.size());
4751  return s;
4752  }
4753 
4754  const std::vector<int64_t>& Type() {
4755  static const int64_t values[] = {
4756  0L,
4757  1L,
4758  2L,
4759  3L
4760  };
4761  static const std::vector<int64_t> retval(values, values + 4);
4762  return retval;
4763  }
4764 
4765 }}}}
4766 
4767 namespace Rose {
4768  std::string stringifyBinaryAnalysisSmtSolverType(int64_t i, const char *strip, bool canonic) {
4769  std::string retval = stringify::Rose::BinaryAnalysis::SmtSolver::Type(i);
4770  if (retval.empty()) {
4771  retval = "(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
4772  } else {
4773  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4774  retval = retval.substr(strlen(strip));
4775  if (canonic)
4776  retval = "Rose::BinaryAnalysis::SmtSolver::Type::" + retval;
4777  }
4778  return retval;
4779  }
4780 
4781  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverType() {
4783  }
4784 }
4785 
4786 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4787 // /src/midend/BinaryAnalysis/BinarySmtSolver.h line 78
4788 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
4789  const char* Satisfiable(int64_t i) {
4790  switch (i) {
4791  case 0L: return "SAT_NO";
4792  case 1L: return "SAT_YES";
4793  case 2L: return "SAT_UNKNOWN";
4794  default: return "";
4795  }
4796  }
4797 
4798  std::string Satisfiable(int64_t i, const std::string &strip) {
4799  std::string s = Satisfiable(i);
4800  if (s.empty())
4801  s = "(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
4802  if (boost::starts_with(s, strip))
4803  s = s.substr(strip.size());
4804  return s;
4805  }
4806 
4807  const std::vector<int64_t>& Satisfiable() {
4808  static const int64_t values[] = {
4809  0L,
4810  1L,
4811  2L
4812  };
4813  static const std::vector<int64_t> retval(values, values + 3);
4814  return retval;
4815  }
4816 
4817 }}}}
4818 
4819 namespace Rose {
4820  std::string stringifyBinaryAnalysisSmtSolverSatisfiable(int64_t i, const char *strip, bool canonic) {
4822  if (retval.empty()) {
4823  retval = "(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
4824  } else {
4825  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4826  retval = retval.substr(strlen(strip));
4827  if (canonic)
4828  retval = "Rose::BinaryAnalysis::SmtSolver::Satisfiable::" + retval;
4829  }
4830  return retval;
4831  }
4832 
4833  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverSatisfiable() {
4835  }
4836 }
4837 
4838 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4839 // /src/midend/BinaryAnalysis/BinaryDebugger.C line 20
4840 namespace stringify {
4841  const char* __ptrace_request(int64_t i) {
4842  switch (i) {
4843  case 0L: return "PTRACE_ATTACH";
4844  case 1L: return "PTRACE_CONT";
4845  case 2L: return "PTRACE_DETACH";
4846  case 3L: return "PTRACE_GETREGS";
4847  case 4L: return "PTRACE_GETFPREGS";
4848  case 5L: return "PTRACE_KILL";
4849  case 6L: return "PTRACE_SETREGS";
4850  case 7L: return "PTRACE_SINGLESTEP";
4851  case 8L: return "PTRACE_TRACEME";
4852  case 9L: return "PTRACE_PEEKUSER";
4853  default: return "";
4854  }
4855  }
4856 
4857  std::string __ptrace_request(int64_t i, const std::string &strip) {
4858  std::string s = __ptrace_request(i);
4859  if (s.empty())
4860  s = "(__ptrace_request)" + boost::lexical_cast<std::string>(i);
4861  if (boost::starts_with(s, strip))
4862  s = s.substr(strip.size());
4863  return s;
4864  }
4865 
4866  const std::vector<int64_t>& __ptrace_request() {
4867  static const int64_t values[] = {
4868  0L,
4869  1L,
4870  2L,
4871  3L,
4872  4L,
4873  5L,
4874  6L,
4875  7L,
4876  8L,
4877  9L
4878  };
4879  static const std::vector<int64_t> retval(values, values + 10);
4880  return retval;
4881  }
4882 
4883 }
4884 
4885 namespace Rose {
4886  std::string stringify__ptrace_request(int64_t i, const char *strip, bool canonic) {
4887  std::string retval = stringify::__ptrace_request(i);
4888  if (retval.empty()) {
4889  retval = "(__ptrace_request)" + boost::lexical_cast<std::string>(i);
4890  } else {
4891  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4892  retval = retval.substr(strlen(strip));
4893  if (canonic)
4894  retval = "__ptrace_request::" + retval;
4895  }
4896  return retval;
4897  }
4898 
4899  const std::vector<int64_t>& stringify__ptrace_request() {
4900  return stringify::__ptrace_request();
4901  }
4902 }
4903 
4904 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4905 // /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 12
4906 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Commit {
4907  const char* Boolean(int64_t i) {
4908  switch (i) {
4909  case 0L: return "NO";
4910  case 1L: return "YES";
4911  default: return "";
4912  }
4913  }
4914 
4915  std::string Boolean(int64_t i, const std::string &strip) {
4916  std::string s = Boolean(i);
4917  if (s.empty())
4918  s = "(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
4919  if (boost::starts_with(s, strip))
4920  s = s.substr(strip.size());
4921  return s;
4922  }
4923 
4924  const std::vector<int64_t>& Boolean() {
4925  static const int64_t values[] = {
4926  0L,
4927  1L
4928  };
4929  static const std::vector<int64_t> retval(values, values + 2);
4930  return retval;
4931  }
4932 
4933 }}}}
4934 
4935 namespace Rose {
4936  std::string stringifyBinaryAnalysisCommitBoolean(int64_t i, const char *strip, bool canonic) {
4937  std::string retval = stringify::Rose::BinaryAnalysis::Commit::Boolean(i);
4938  if (retval.empty()) {
4939  retval = "(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
4940  } else {
4941  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4942  retval = retval.substr(strlen(strip));
4943  if (canonic)
4944  retval = "Rose::BinaryAnalysis::Commit::Boolean::" + retval;
4945  }
4946  return retval;
4947  }
4948 
4949  const std::vector<int64_t>& stringifyBinaryAnalysisCommitBoolean() {
4951  }
4952 }
4953 
4954 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4955 // /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 22
4956 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
4957  const char* AggregationDirection(int64_t i) {
4958  switch (i) {
4959  case 1L: return "AGGREGATE_PREDECESSORS";
4960  case 2L: return "AGGREGATE_SUCCESSORS";
4961  default: return "";
4962  }
4963  }
4964 
4965  std::string AggregationDirection(int64_t i, const std::string &strip) {
4966  std::string s = AggregationDirection(i);
4967  if (s.empty())
4968  s = "(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
4969  if (boost::starts_with(s, strip))
4970  s = s.substr(strip.size());
4971  return s;
4972  }
4973 
4974  const std::vector<int64_t>& AggregationDirection() {
4975  static const int64_t values[] = {
4976  1L,
4977  2L
4978  };
4979  static const std::vector<int64_t> retval(values, values + 2);
4980  return retval;
4981  }
4982 
4983 }}}}
4984 
4985 namespace Rose {
4986  std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(int64_t i, const char *strip, bool canonic) {
4988  if (retval.empty()) {
4989  retval = "(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
4990  } else {
4991  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4992  retval = retval.substr(strlen(strip));
4993  if (canonic)
4994  retval = "Rose::BinaryAnalysis::CodeInserter::AggregationDirection::" + retval;
4995  }
4996  return retval;
4997  }
4998 
4999  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterAggregationDirection() {
5001  }
5002 }
5003 
5004 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5005 // /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 28
5006 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
5007  const char* NopPadding(int64_t i) {
5008  switch (i) {
5009  case 0L: return "PAD_NOP_BACK";
5010  case 1L: return "PAD_NOP_FRONT";
5011  case 2L: return "PAD_RANDOM_BACK";
5012  default: return "";
5013  }
5014  }
5015 
5016  std::string NopPadding(int64_t i, const std::string &strip) {
5017  std::string s = NopPadding(i);
5018  if (s.empty())
5019  s = "(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
5020  if (boost::starts_with(s, strip))
5021  s = s.substr(strip.size());
5022  return s;
5023  }
5024 
5025  const std::vector<int64_t>& NopPadding() {
5026  static const int64_t values[] = {
5027  0L,
5028  1L,
5029  2L
5030  };
5031  static const std::vector<int64_t> retval(values, values + 3);
5032  return retval;
5033  }
5034 
5035 }}}}
5036 
5037 namespace Rose {
5038  std::string stringifyBinaryAnalysisCodeInserterNopPadding(int64_t i, const char *strip, bool canonic) {
5040  if (retval.empty()) {
5041  retval = "(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
5042  } else {
5043  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5044  retval = retval.substr(strlen(strip));
5045  if (canonic)
5046  retval = "Rose::BinaryAnalysis::CodeInserter::NopPadding::" + retval;
5047  }
5048  return retval;
5049  }
5050 
5051  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterNopPadding() {
5053  }
5054 }
5055 
5056 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5057 // /src/midend/BinaryAnalysis/BinaryCodeInserter.h line 52
5058 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
5059  const char* RelocType(int64_t i) {
5060  switch (i) {
5061  case 0L: return "RELOC_INDEX_ABS_LE32";
5062  case 1L: return "RELOC_INDEX_ABS_LE32HI";
5063  case 2L: return "RELOC_INDEX_ABS_BE32";
5064  case 3L: return "RELOC_ADDR_REL_LE32";
5065  case 4L: return "RELOC_ADDR_REL_BE32";
5066  case 5L: return "RELOC_INSN_ABS_LE32";
5067  case 6L: return "RELOC_INSN_REL_LE32";
5068  case 7L: return "RELOC_INSN_REL_BE32";
5069  default: return "";
5070  }
5071  }
5072 
5073  std::string RelocType(int64_t i, const std::string &strip) {
5074  std::string s = RelocType(i);
5075  if (s.empty())
5076  s = "(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
5077  if (boost::starts_with(s, strip))
5078  s = s.substr(strip.size());
5079  return s;
5080  }
5081 
5082  const std::vector<int64_t>& RelocType() {
5083  static const int64_t values[] = {
5084  0L,
5085  1L,
5086  2L,
5087  3L,
5088  4L,
5089  5L,
5090  6L,
5091  7L
5092  };
5093  static const std::vector<int64_t> retval(values, values + 8);
5094  return retval;
5095  }
5096 
5097 }}}}
5098 
5099 namespace Rose {
5100  std::string stringifyBinaryAnalysisCodeInserterRelocType(int64_t i, const char *strip, bool canonic) {
5102  if (retval.empty()) {
5103  retval = "(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
5104  } else {
5105  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5106  retval = retval.substr(strlen(strip));
5107  if (canonic)
5108  retval = "Rose::BinaryAnalysis::CodeInserter::RelocType::" + retval;
5109  }
5110  return retval;
5111  }
5112 
5113  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterRelocType() {
5115  }
5116 }
5117 
5118 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5119 // /src/midend/BinaryAnalysis/libraryIdentification/FunctionIdDatabaseInterface.h line 28
5120 namespace stringify { namespace LibraryIdentification {
5121  const char* DUPLICATE_OPTION(int64_t i) {
5122  switch (i) {
5123  case 0L: return "UNKNOWN";
5124  case 1L: return "COMBINE";
5125  case 2L: return "REPLACE";
5126  case 3L: return "NO_ADD";
5127  default: return "";
5128  }
5129  }
5130 
5131  std::string DUPLICATE_OPTION(int64_t i, const std::string &strip) {
5132  std::string s = DUPLICATE_OPTION(i);
5133  if (s.empty())
5134  s = "(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
5135  if (boost::starts_with(s, strip))
5136  s = s.substr(strip.size());
5137  return s;
5138  }
5139 
5140  const std::vector<int64_t>& DUPLICATE_OPTION() {
5141  static const int64_t values[] = {
5142  0L,
5143  1L,
5144  2L,
5145  3L
5146  };
5147  static const std::vector<int64_t> retval(values, values + 4);
5148  return retval;
5149  }
5150 
5151 }}
5152 
5153 namespace Rose {
5154  std::string stringifyLibraryIdentificationDUPLICATE_OPTION(int64_t i, const char *strip, bool canonic) {
5156  if (retval.empty()) {
5157  retval = "(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
5158  } else {
5159  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5160  retval = retval.substr(strlen(strip));
5161  if (canonic)
5162  retval = "LibraryIdentification::DUPLICATE_OPTION::" + retval;
5163  }
5164  return retval;
5165  }
5166 
5167  const std::vector<int64_t>& stringifyLibraryIdentificationDUPLICATE_OPTION() {
5169  }
5170 }
5171 
5172 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5173 // /src/midend/BinaryAnalysis/Concolic/ConcolicExecutor.h line 25
5174 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace InputVariables { namespace Variable {
5175  const char* Whence(int64_t i) {
5176  switch (i) {
5177  case 0L: return "INVALID";
5178  case 1L: return "PROGRAM_ARGUMENT_COUNT";
5179  case 2L: return "PROGRAM_ARGUMENT";
5180  case 3L: return "ENVIRONMENT";
5181  default: return "";
5182  }
5183  }
5184 
5185  std::string Whence(int64_t i, const std::string &strip) {
5186  std::string s = Whence(i);
5187  if (s.empty())
5188  s = "(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
5189  if (boost::starts_with(s, strip))
5190  s = s.substr(strip.size());
5191  return s;
5192  }
5193 
5194  const std::vector<int64_t>& Whence() {
5195  static const int64_t values[] = {
5196  0L,
5197  1L,
5198  2L,
5199  3L
5200  };
5201  static const std::vector<int64_t> retval(values, values + 4);
5202  return retval;
5203  }
5204 
5205 }}}}}}
5206 
5207 namespace Rose {
5208  std::string stringifyBinaryAnalysisConcolicInputVariablesVariableWhence(int64_t i, const char *strip, bool canonic) {
5210  if (retval.empty()) {
5211  retval = "(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
5212  } else {
5213  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5214  retval = retval.substr(strlen(strip));
5215  if (canonic)
5216  retval = "Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence::" + retval;
5217  }
5218  return retval;
5219  }
5220 
5221  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicInputVariablesVariableWhence() {
5223  }
5224 }
5225 
5226 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5227 // /src/midend/BinaryAnalysis/BinaryFunctionSimilarity.h line 71
5228 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
5229  const char* CValKind(int64_t i) {
5230  switch (i) {
5231  case 0L: return "CARTESIAN_POINT";
5232  case 1L: return "ORDERED_LIST";
5233  default: return "";
5234  }
5235  }
5236 
5237  std::string CValKind(int64_t i, const std::string &strip) {
5238  std::string s = CValKind(i);
5239  if (s.empty())
5240  s = "(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
5241  if (boost::starts_with(s, strip))
5242  s = s.substr(strip.size());
5243  return s;
5244  }
5245 
5246  const std::vector<int64_t>& CValKind() {
5247  static const int64_t values[] = {
5248  0L,
5249  1L
5250  };
5251  static const std::vector<int64_t> retval(values, values + 2);
5252  return retval;
5253  }
5254 
5255 }}}}
5256 
5257 namespace Rose {
5258  std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(int64_t i, const char *strip, bool canonic) {
5260  if (retval.empty()) {
5261  retval = "(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
5262  } else {
5263  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5264  retval = retval.substr(strlen(strip));
5265  if (canonic)
5266  retval = "Rose::BinaryAnalysis::FunctionSimilarity::CValKind::" + retval;
5267  }
5268  return retval;
5269  }
5270 
5271  const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityCValKind() {
5273  }
5274 }
5275 
5276 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5277 // /src/midend/BinaryAnalysis/BinaryFunctionSimilarity.h line 83
5278 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
5279  const char* Statistic(int64_t i) {
5280  switch (i) {
5281  case 0L: return "AVERAGE";
5282  case 1L: return "MEDIAN";
5283  case 2L: return "MAXIMUM";
5284  default: return "";
5285  }
5286  }
5287 
5288  std::string Statistic(int64_t i, const std::string &strip) {
5289  std::string s = Statistic(i);
5290  if (s.empty())
5291  s = "(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
5292  if (boost::starts_with(s, strip))
5293  s = s.substr(strip.size());
5294  return s;
5295  }
5296 
5297  const std::vector<int64_t>& Statistic() {
5298  static const int64_t values[] = {
5299  0L,
5300  1L,
5301  2L
5302  };
5303  static const std::vector<int64_t> retval(values, values + 3);
5304  return retval;
5305  }
5306 
5307 }}}}
5308 
5309 namespace Rose {
5310  std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(int64_t i, const char *strip, bool canonic) {
5312  if (retval.empty()) {
5313  retval = "(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
5314  } else {
5315  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5316  retval = retval.substr(strlen(strip));
5317  if (canonic)
5318  retval = "Rose::BinaryAnalysis::FunctionSimilarity::Statistic::" + retval;
5319  }
5320  return retval;
5321  }
5322 
5323  const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityStatistic() {
5325  }
5326 }
5327 
5328 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5329 // /src/midend/BinaryAnalysis/instructionSemantics/DispatcherX86.h line 176
5330 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DispatcherX86 {
5331  const char* AccessMode(int64_t i) {
5332  switch (i) {
5333  case 0L: return "READ_REGISTER";
5334  case 1L: return "PEEK_REGISTER";
5335  default: return "";
5336  }
5337  }
5338 
5339  std::string AccessMode(int64_t i, const std::string &strip) {
5340  std::string s = AccessMode(i);
5341  if (s.empty())
5342  s = "(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
5343  if (boost::starts_with(s, strip))
5344  s = s.substr(strip.size());
5345  return s;
5346  }
5347 
5348  const std::vector<int64_t>& AccessMode() {
5349  static const int64_t values[] = {
5350  0L,
5351  1L
5352  };
5353  static const std::vector<int64_t> retval(values, values + 2);
5354  return retval;
5355  }
5356 
5357 }}}}}
5358 
5359 namespace Rose {
5360  std::string stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode(int64_t i, const char *strip, bool canonic) {
5362  if (retval.empty()) {
5363  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
5364  } else {
5365  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5366  retval = retval.substr(strlen(strip));
5367  if (canonic)
5368  retval = "Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode::" + retval;
5369  }
5370  return retval;
5371  }
5372 
5373  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode() {
5375  }
5376 }
5377 
5378 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5379 // /src/midend/BinaryAnalysis/instructionSemantics/DataFlowSemantics2.h line 35
5380 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace DataFlowSemantics { namespace DataFlowEdge {
5381  const char* EdgeType(int64_t i) {
5382  switch (i) {
5383  case 0L: return "CLOBBER";
5384  case 1L: return "AUGMENT";
5385  default: return "";
5386  }
5387  }
5388 
5389  std::string EdgeType(int64_t i, const std::string &strip) {
5390  std::string s = EdgeType(i);
5391  if (s.empty())
5392  s = "(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
5393  if (boost::starts_with(s, strip))
5394  s = s.substr(strip.size());
5395  return s;
5396  }
5397 
5398  const std::vector<int64_t>& EdgeType() {
5399  static const int64_t values[] = {
5400  0L,
5401  1L
5402  };
5403  static const std::vector<int64_t> retval(values, values + 2);
5404  return retval;
5405  }
5406 
5407 }}}}}}
5408 
5409 namespace Rose {
5410  std::string stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType(int64_t i, const char *strip, bool canonic) {
5412  if (retval.empty()) {
5413  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
5414  } else {
5415  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5416  retval = retval.substr(strlen(strip));
5417  if (canonic)
5418  retval = "Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType::" + retval;
5419  }
5420  return retval;
5421  }
5422 
5423  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType() {
5425  }
5426 }
5427 
5428 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5429 // /src/midend/BinaryAnalysis/instructionSemantics/DispatcherPowerpc.C line 15
5430 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace UpdateCr {
5431  const char* Flag(int64_t i) {
5432  switch (i) {
5433  case 0L: return "NO";
5434  case 1L: return "YES";
5435  default: return "";
5436  }
5437  }
5438 
5439  std::string Flag(int64_t i, const std::string &strip) {
5440  std::string s = Flag(i);
5441  if (s.empty())
5442  s = "(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
5443  if (boost::starts_with(s, strip))
5444  s = s.substr(strip.size());
5445  return s;
5446  }
5447 
5448  const std::vector<int64_t>& Flag() {
5449  static const int64_t values[] = {
5450  0L,
5451  1L
5452  };
5453  static const std::vector<int64_t> retval(values, values + 2);
5454  return retval;
5455  }
5456 
5457 }}}}}
5458 
5459 namespace Rose {
5460  std::string stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag(int64_t i, const char *strip, bool canonic) {
5462  if (retval.empty()) {
5463  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
5464  } else {
5465  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5466  retval = retval.substr(strlen(strip));
5467  if (canonic)
5468  retval = "Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag::" + retval;
5469  }
5470  return retval;
5471  }
5472 
5473  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag() {
5475  }
5476 }
5477 
5478 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5479 // /src/midend/BinaryAnalysis/instructionSemantics/DispatcherPowerpc.C line 19
5480 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SaveLink {
5481  const char* Flag(int64_t i) {
5482  switch (i) {
5483  case 0L: return "NO";
5484  case 1L: return "YES";
5485  default: return "";
5486  }
5487  }
5488 
5489  std::string Flag(int64_t i, const std::string &strip) {
5490  std::string s = Flag(i);
5491  if (s.empty())
5492  s = "(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
5493  if (boost::starts_with(s, strip))
5494  s = s.substr(strip.size());
5495  return s;
5496  }
5497 
5498  const std::vector<int64_t>& Flag() {
5499  static const int64_t values[] = {
5500  0L,
5501  1L
5502  };
5503  static const std::vector<int64_t> retval(values, values + 2);
5504  return retval;
5505  }
5506 
5507 }}}}}
5508 
5509 namespace Rose {
5510  std::string stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag(int64_t i, const char *strip, bool canonic) {
5512  if (retval.empty()) {
5513  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
5514  } else {
5515  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5516  retval = retval.substr(strlen(strip));
5517  if (canonic)
5518  retval = "Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag::" + retval;
5519  }
5520  return retval;
5521  }
5522 
5523  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag() {
5525  }
5526 }
5527 
5528 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5529 // /src/midend/BinaryAnalysis/instructionSemantics/IntervalSemantics2.C line 652
5530 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace IntervalSemantics {
5531  const char* Carry(int64_t i) {
5532  switch (i) {
5533  case 0L: return "C_FALSE";
5534  case 1L: return "C_TRUE";
5535  case 2L: return "C_UNKNOWN";
5536  default: return "";
5537  }
5538  }
5539 
5540  std::string Carry(int64_t i, const std::string &strip) {
5541  std::string s = Carry(i);
5542  if (s.empty())
5543  s = "(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
5544  if (boost::starts_with(s, strip))
5545  s = s.substr(strip.size());
5546  return s;
5547  }
5548 
5549  const std::vector<int64_t>& Carry() {
5550  static const int64_t values[] = {
5551  0L,
5552  1L,
5553  2L
5554  };
5555  static const std::vector<int64_t> retval(values, values + 3);
5556  return retval;
5557  }
5558 
5559 }}}}}
5560 
5561 namespace Rose {
5562  std::string stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry(int64_t i, const char *strip, bool canonic) {
5564  if (retval.empty()) {
5565  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
5566  } else {
5567  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5568  retval = retval.substr(strlen(strip));
5569  if (canonic)
5570  retval = "Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry::" + retval;
5571  }
5572  return retval;
5573  }
5574 
5575  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry() {
5577  }
5578 }
5579 
5580 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5581 // /src/midend/BinaryAnalysis/instructionSemantics/BaseSemanticsTypes.h line 75
5582 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace BaseSemantics {
5583  const char* InputOutputProperty(int64_t i) {
5584  switch (i) {
5585  case 0L: return "IO_READ";
5586  case 1L: return "IO_WRITE";
5587  case 2L: return "IO_INIT";
5588  case 3L: return "IO_READ_BEFORE_WRITE";
5589  case 4L: return "IO_READ_AFTER_WRITE";
5590  case 5L: return "IO_READ_UNINITIALIZED";
5591  default: return "";
5592  }
5593  }
5594 
5595  std::string InputOutputProperty(int64_t i, const std::string &strip) {
5596  std::string s = InputOutputProperty(i);
5597  if (s.empty())
5598  s = "(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
5599  if (boost::starts_with(s, strip))
5600  s = s.substr(strip.size());
5601  return s;
5602  }
5603 
5604  const std::vector<int64_t>& InputOutputProperty() {
5605  static const int64_t values[] = {
5606  0L,
5607  1L,
5608  2L,
5609  3L,
5610  4L,
5611  5L
5612  };
5613  static const std::vector<int64_t> retval(values, values + 6);
5614  return retval;
5615  }
5616 
5617 }}}}}
5618 
5619 namespace Rose {
5620  std::string stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty(int64_t i, const char *strip, bool canonic) {
5622  if (retval.empty()) {
5623  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
5624  } else {
5625  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5626  retval = retval.substr(strlen(strip));
5627  if (canonic)
5628  retval = "Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty::" + retval;
5629  }
5630  return retval;
5631  }
5632 
5633  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty() {
5635  }
5636 }
5637 
5638 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5639 // /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 63
5640 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics { namespace AllowSideEffects {
5641  const char* Flag(int64_t i) {
5642  switch (i) {
5643  case 0L: return "NO";
5644  case 1L: return "YES";
5645  default: return "";
5646  }
5647  }
5648 
5649  std::string Flag(int64_t i, const std::string &strip) {
5650  std::string s = Flag(i);
5651  if (s.empty())
5652  s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
5653  if (boost::starts_with(s, strip))
5654  s = s.substr(strip.size());
5655  return s;
5656  }
5657 
5658  const std::vector<int64_t>& Flag() {
5659  static const int64_t values[] = {
5660  0L,
5661  1L
5662  };
5663  static const std::vector<int64_t> retval(values, values + 2);
5664  return retval;
5665  }
5666 
5667 }}}}}}
5668 
5669 namespace Rose {
5670  std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag(int64_t i, const char *strip, bool canonic) {
5672  if (retval.empty()) {
5673  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
5674  } else {
5675  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5676  retval = retval.substr(strlen(strip));
5677  if (canonic)
5678  retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag::" + retval;
5679  }
5680  return retval;
5681  }
5682 
5683  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag() {
5685  }
5686 }
5687 
5688 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5689 // /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 767
5690 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
5691  const char* WritersMode(int64_t i) {
5692  switch (i) {
5693  case 0L: return "TRACK_NO_WRITERS";
5694  case 1L: return "TRACK_LATEST_WRITER";
5695  case 2L: return "TRACK_ALL_WRITERS";
5696  default: return "";
5697  }
5698  }
5699 
5700  std::string WritersMode(int64_t i, const std::string &strip) {
5701  std::string s = WritersMode(i);
5702  if (s.empty())
5703  s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
5704  if (boost::starts_with(s, strip))
5705  s = s.substr(strip.size());
5706  return s;
5707  }
5708 
5709  const std::vector<int64_t>& WritersMode() {
5710  static const int64_t values[] = {
5711  0L,
5712  1L,
5713  2L
5714  };
5715  static const std::vector<int64_t> retval(values, values + 3);
5716  return retval;
5717  }
5718 
5719 }}}}}
5720 
5721 namespace Rose {
5722  std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode(int64_t i, const char *strip, bool canonic) {
5724  if (retval.empty()) {
5725  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
5726  } else {
5727  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5728  retval = retval.substr(strlen(strip));
5729  if (canonic)
5730  retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode::" + retval;
5731  }
5732  return retval;
5733  }
5734 
5735  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode() {
5737  }
5738 }
5739 
5740 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5741 // /src/midend/BinaryAnalysis/instructionSemantics/SymbolicSemantics2.h line 774
5742 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics2 { namespace SymbolicSemantics {
5743  const char* DefinersMode(int64_t i) {
5744  switch (i) {
5745  case 0L: return "TRACK_NO_DEFINERS";
5746  case 1L: return "TRACK_LATEST_DEFINER";
5747  case 2L: return "TRACK_ALL_DEFINERS";
5748  default: return "";
5749  }
5750  }
5751 
5752  std::string DefinersMode(int64_t i, const std::string &strip) {
5753  std::string s = DefinersMode(i);
5754  if (s.empty())
5755  s = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
5756  if (boost::starts_with(s, strip))
5757  s = s.substr(strip.size());
5758  return s;
5759  }
5760 
5761  const std::vector<int64_t>& DefinersMode() {
5762  static const int64_t values[] = {
5763  0L,
5764  1L,
5765  2L
5766  };
5767  static const std::vector<int64_t> retval(values, values + 3);
5768  return retval;
5769  }
5770 
5771 }}}}}
5772 
5773 namespace Rose {
5774  std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode(int64_t i, const char *strip, bool canonic) {
5776  if (retval.empty()) {
5777  retval = "(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
5778  } else {
5779  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5780  retval = retval.substr(strlen(strip));
5781  if (canonic)
5782  retval = "Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode::" + retval;
5783  }
5784  return retval;
5785  }
5786 
5787  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode() {
5789  }
5790 }
5791 
5792 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5793 // /src/midend/BinaryAnalysis/BinaryString.h line 195
5794 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Strings {
5795  const char* State(int64_t i) {
5796  switch (i) {
5797  case -4L: return "ERROR_STATE";
5798  case -3L: return "INITIAL_STATE";
5799  case -2L: return "COMPLETED_STATE";
5800  case -1L: return "FINAL_STATE";
5801  case 0L: return "USER_DEFINED_0";
5802  case 1L: return "USER_DEFINED_1";
5803  case 2L: return "USER_DEFINED_2";
5804  case 128L: return "USER_DEFINED_MAX";
5805  default: return "";
5806  }
5807  }
5808 
5809  std::string State(int64_t i, const std::string &strip) {
5810  std::string s = State(i);
5811  if (s.empty())
5812  s = "(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
5813  if (boost::starts_with(s, strip))
5814  s = s.substr(strip.size());
5815  return s;
5816  }
5817 
5818  const std::vector<int64_t>& State() {
5819  static const int64_t values[] = {
5820  -4L,
5821  -3L,
5822  -2L,
5823  -1L,
5824  0L,
5825  1L,
5826  2L,
5827  128L
5828  };
5829  static const std::vector<int64_t> retval(values, values + 8);
5830  return retval;
5831  }
5832 
5833 }}}}
5834 
5835 namespace Rose {
5836  std::string stringifyBinaryAnalysisStringsState(int64_t i, const char *strip, bool canonic) {
5837  std::string retval = stringify::Rose::BinaryAnalysis::Strings::State(i);
5838  if (retval.empty()) {
5839  retval = "(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
5840  } else {
5841  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5842  retval = retval.substr(strlen(strip));
5843  if (canonic)
5844  retval = "Rose::BinaryAnalysis::Strings::State::" + retval;
5845  }
5846  return retval;
5847  }
5848 
5849  const std::vector<int64_t>& stringifyBinaryAnalysisStringsState() {
5851  }
5852 }
5853 
5854 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5855 // /src/midend/BinaryAnalysis/BinaryTaintedFlow.h line 23
5856 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
5857  const char* Taintedness(int64_t i) {
5858  switch (i) {
5859  case 0L: return "BOTTOM";
5860  case 1L: return "NOT_TAINTED";
5861  case 2L: return "TAINTED";
5862  case 3L: return "TOP";
5863  default: return "";
5864  }
5865  }
5866 
5867  std::string Taintedness(int64_t i, const std::string &strip) {
5868  std::string s = Taintedness(i);
5869  if (s.empty())
5870  s = "(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
5871  if (boost::starts_with(s, strip))
5872  s = s.substr(strip.size());
5873  return s;
5874  }
5875 
5876  const std::vector<int64_t>& Taintedness() {
5877  static const int64_t values[] = {
5878  0L,
5879  1L,
5880  2L,
5881  3L
5882  };
5883  static const std::vector<int64_t> retval(values, values + 4);
5884  return retval;
5885  }
5886 
5887 }}}}
5888 
5889 namespace Rose {
5890  std::string stringifyBinaryAnalysisTaintedFlowTaintedness(int64_t i, const char *strip, bool canonic) {
5892  if (retval.empty()) {
5893  retval = "(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
5894  } else {
5895  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5896  retval = retval.substr(strlen(strip));
5897  if (canonic)
5898  retval = "Rose::BinaryAnalysis::TaintedFlow::Taintedness::" + retval;
5899  }
5900  return retval;
5901  }
5902 
5903  const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowTaintedness() {
5905  }
5906 }
5907 
5908 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5909 // /src/midend/BinaryAnalysis/BinaryTaintedFlow.h line 30
5910 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
5911  const char* Approximation(int64_t i) {
5912  switch (i) {
5913  case 0L: return "UNDER_APPROXIMATE";
5914  case 1L: return "OVER_APPROXIMATE";
5915  default: return "";
5916  }
5917  }
5918 
5919  std::string Approximation(int64_t i, const std::string &strip) {
5920  std::string s = Approximation(i);
5921  if (s.empty())
5922  s = "(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
5923  if (boost::starts_with(s, strip))
5924  s = s.substr(strip.size());
5925  return s;
5926  }
5927 
5928  const std::vector<int64_t>& Approximation() {
5929  static const int64_t values[] = {
5930  0L,
5931  1L
5932  };
5933  static const std::vector<int64_t> retval(values, values + 2);
5934  return retval;
5935  }
5936 
5937 }}}}
5938 
5939 namespace Rose {
5940  std::string stringifyBinaryAnalysisTaintedFlowApproximation(int64_t i, const char *strip, bool canonic) {
5942  if (retval.empty()) {
5943  retval = "(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
5944  } else {
5945  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5946  retval = retval.substr(strlen(strip));
5947  if (canonic)
5948  retval = "Rose::BinaryAnalysis::TaintedFlow::Approximation::" + retval;
5949  }
5950  return retval;
5951  }
5952 
5953  const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowApproximation() {
5955  }
5956 }
5957 
5958 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5959 // /src/midend/BinaryAnalysis/BinaryHotPatch.h line 29
5960 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
5961  const char* Type(int64_t i) {
5962  switch (i) {
5963  case 0L: return "PATCH_REGISTER";
5964  case 1L: return "PATCH_NONE";
5965  default: return "";
5966  }
5967  }
5968 
5969  std::string Type(int64_t i, const std::string &strip) {
5970  std::string s = Type(i);
5971  if (s.empty())
5972  s = "(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
5973  if (boost::starts_with(s, strip))
5974  s = s.substr(strip.size());
5975  return s;
5976  }
5977 
5978  const std::vector<int64_t>& Type() {
5979  static const int64_t values[] = {
5980  0L,
5981  1L
5982  };
5983  static const std::vector<int64_t> retval(values, values + 2);
5984  return retval;
5985  }
5986 
5987 }}}}}
5988 
5989 namespace Rose {
5990  std::string stringifyBinaryAnalysisHotPatchRecordType(int64_t i, const char *strip, bool canonic) {
5992  if (retval.empty()) {
5993  retval = "(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
5994  } else {
5995  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5996  retval = retval.substr(strlen(strip));
5997  if (canonic)
5998  retval = "Rose::BinaryAnalysis::HotPatch::Record::Type::" + retval;
5999  }
6000  return retval;
6001  }
6002 
6003  const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordType() {
6005  }
6006 }
6007 
6008 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6009 // /src/midend/BinaryAnalysis/BinaryHotPatch.h line 35
6010 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
6011  const char* Behavior(int64_t i) {
6012  switch (i) {
6013  case 0L: return "MATCH_CONTINUE";
6014  case 1L: return "MATCH_BREAK";
6015  default: