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