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