ROSE  0.9.12.24
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/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qcodeedit.h line 46
8 namespace stringify { namespace QCodeEdit {
9  const char* Position(int64_t i) {
10  switch (i) {
11  case 0L: return "West";
12  case 1L: return "North";
13  case 2L: return "South";
14  case 3L: return "East";
15  default: return "";
16  }
17  }
18 
19  std::string Position(int64_t i, const std::string &strip) {
20  std::string s = Position(i);
21  if (s.empty())
22  s = "(QCodeEdit::Position)" + boost::lexical_cast<std::string>(i);
23  if (boost::starts_with(s, strip))
24  s = s.substr(strip.size());
25  return s;
26  }
27 
28  const std::vector<int64_t>& Position() {
29  static const int64_t values[] = {
30  0L,
31  1L,
32  2L,
33  3L
34  };
35  static const std::vector<int64_t> retval(values, values + 4);
36  return retval;
37  }
38 
39 }}
40 
41 namespace Rose {
42  std::string stringifyQCodeEditPosition(int64_t i, const char *strip, bool canonic) {
43  std::string retval = stringify::QCodeEdit::Position(i);
44  if (retval.empty()) {
45  retval = "(QCodeEdit::Position)" + boost::lexical_cast<std::string>(i);
46  } else {
47  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
48  retval = retval.substr(strlen(strip));
49  if (canonic)
50  retval = "QCodeEdit::Position::" + retval;
51  }
52  return retval;
53  }
54 
55  const std::vector<int64_t>& stringifyQCodeEditPosition() {
57  }
58 }
59 
60 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
61 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qlanguagedefinition.h line 44
62 namespace stringify { namespace QLanguageDefinition {
63  const char* CollapseFlag(int64_t i) {
64  switch (i) {
65  case 0L: return "None";
66  case 4095L: return "OpenMask";
67  case 16773120L: return "CloseMask";
68  case 268435456L: return "Collapsible";
69  case 536870912L: return "Collapsed";
70  case 1073741824L: return "Closure";
71  default: return "";
72  }
73  }
74 
75  std::string CollapseFlag(int64_t i, const std::string &strip) {
76  std::string s = CollapseFlag(i);
77  if (s.empty())
78  s = "(QLanguageDefinition::CollapseFlag)" + boost::lexical_cast<std::string>(i);
79  if (boost::starts_with(s, strip))
80  s = s.substr(strip.size());
81  return s;
82  }
83 
84  const std::vector<int64_t>& CollapseFlag() {
85  static const int64_t values[] = {
86  0L,
87  4095L,
88  16773120L,
89  268435456L,
90  536870912L,
91  1073741824L
92  };
93  static const std::vector<int64_t> retval(values, values + 6);
94  return retval;
95  }
96 
97 }}
98 
99 namespace Rose {
100  std::string stringifyQLanguageDefinitionCollapseFlag(int64_t i, const char *strip, bool canonic) {
101  std::string retval = stringify::QLanguageDefinition::CollapseFlag(i);
102  if (retval.empty()) {
103  retval = "(QLanguageDefinition::CollapseFlag)" + boost::lexical_cast<std::string>(i);
104  } else {
105  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
106  retval = retval.substr(strlen(strip));
107  if (canonic)
108  retval = "QLanguageDefinition::CollapseFlag::" + retval;
109  }
110  return retval;
111  }
112 
113  const std::vector<int64_t>& stringifyQLanguageDefinitionCollapseFlag() {
115  }
116 }
117 
118 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
119 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qreliablefilewatch.h line 52
120 namespace stringify { namespace QReliableFileWatch {
121  const char* State(int64_t i) {
122  switch (i) {
123  case 0L: return "Clean";
124  case 1L: return "Recent";
125  case 2L: return "Duplicate";
126  default: return "";
127  }
128  }
129 
130  std::string State(int64_t i, const std::string &strip) {
131  std::string s = State(i);
132  if (s.empty())
133  s = "(QReliableFileWatch::State)" + boost::lexical_cast<std::string>(i);
134  if (boost::starts_with(s, strip))
135  s = s.substr(strip.size());
136  return s;
137  }
138 
139  const std::vector<int64_t>& State() {
140  static const int64_t values[] = {
141  0L,
142  1L,
143  2L
144  };
145  static const std::vector<int64_t> retval(values, values + 3);
146  return retval;
147  }
148 
149 }}
150 
151 namespace Rose {
152  std::string stringifyQReliableFileWatchState(int64_t i, const char *strip, bool canonic) {
153  std::string retval = stringify::QReliableFileWatch::State(i);
154  if (retval.empty()) {
155  retval = "(QReliableFileWatch::State)" + boost::lexical_cast<std::string>(i);
156  } else {
157  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
158  retval = retval.substr(strlen(strip));
159  if (canonic)
160  retval = "QReliableFileWatch::State::" + retval;
161  }
162  return retval;
163  }
164 
165  const std::vector<int64_t>& stringifyQReliableFileWatchState() {
167  }
168 }
169 
170 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
171 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 38
172 namespace stringify { namespace QPanelLayout {
173  const char* Position(int64_t i) {
174  switch (i) {
175  case 0L: return "West";
176  case 1L: return "North";
177  case 2L: return "South";
178  case 3L: return "East";
179  default: return "";
180  }
181  }
182 
183  std::string Position(int64_t i, const std::string &strip) {
184  std::string s = Position(i);
185  if (s.empty())
186  s = "(QPanelLayout::Position)" + boost::lexical_cast<std::string>(i);
187  if (boost::starts_with(s, strip))
188  s = s.substr(strip.size());
189  return s;
190  }
191 
192  const std::vector<int64_t>& Position() {
193  static const int64_t values[] = {
194  0L,
195  1L,
196  2L,
197  3L
198  };
199  static const std::vector<int64_t> retval(values, values + 4);
200  return retval;
201  }
202 
203 }}
204 
205 namespace Rose {
206  std::string stringifyQPanelLayoutPosition(int64_t i, const char *strip, bool canonic) {
207  std::string retval = stringify::QPanelLayout::Position(i);
208  if (retval.empty()) {
209  retval = "(QPanelLayout::Position)" + boost::lexical_cast<std::string>(i);
210  } else {
211  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
212  retval = retval.substr(strlen(strip));
213  if (canonic)
214  retval = "QPanelLayout::Position::" + retval;
215  }
216  return retval;
217  }
218 
219  const std::vector<int64_t>& stringifyQPanelLayoutPosition() {
221  }
222 }
223 
224 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
225 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 87
226 namespace stringify { namespace QPanelLayout {
227  const char* SizeType(int64_t i) {
228  switch (i) {
229  case 0L: return "MinimumSize";
230  case 1L: return "SizeHint";
231  default: return "";
232  }
233  }
234 
235  std::string SizeType(int64_t i, const std::string &strip) {
236  std::string s = SizeType(i);
237  if (s.empty())
238  s = "(QPanelLayout::SizeType)" + 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>& SizeType() {
245  static const int64_t values[] = {
246  0L,
247  1L
248  };
249  static const std::vector<int64_t> retval(values, values + 2);
250  return retval;
251  }
252 
253 }}
254 
255 namespace Rose {
256  std::string stringifyQPanelLayoutSizeType(int64_t i, const char *strip, bool canonic) {
257  std::string retval = stringify::QPanelLayout::SizeType(i);
258  if (retval.empty()) {
259  retval = "(QPanelLayout::SizeType)" + boost::lexical_cast<std::string>(i);
260  } else {
261  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
262  retval = retval.substr(strlen(strip));
263  if (canonic)
264  retval = "QPanelLayout::SizeType::" + retval;
265  }
266  return retval;
267  }
268 
269  const std::vector<int64_t>& stringifyQPanelLayoutSizeType() {
271  }
272 }
273 
274 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
275 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 64
276 namespace stringify { namespace QEditor {
277  const char* CodecUpdatePolicy(int64_t i) {
278  switch (i) {
279  case 0L: return "NoUpdate";
280  case 1L: return "UpdateOld";
281  case 2L: return "UpdateDefault";
282  case 4L: return "UpdateCustom";
283  case 7L: return "UpdateAll";
284  default: return "";
285  }
286  }
287 
288  std::string CodecUpdatePolicy(int64_t i, const std::string &strip) {
289  std::string s = CodecUpdatePolicy(i);
290  if (s.empty())
291  s = "(QEditor::CodecUpdatePolicy)" + boost::lexical_cast<std::string>(i);
292  if (boost::starts_with(s, strip))
293  s = s.substr(strip.size());
294  return s;
295  }
296 
297  const std::vector<int64_t>& CodecUpdatePolicy() {
298  static const int64_t values[] = {
299  0L,
300  1L,
301  2L,
302  4L,
303  7L
304  };
305  static const std::vector<int64_t> retval(values, values + 5);
306  return retval;
307  }
308 
309 }}
310 
311 namespace Rose {
312  std::string stringifyQEditorCodecUpdatePolicy(int64_t i, const char *strip, bool canonic) {
313  std::string retval = stringify::QEditor::CodecUpdatePolicy(i);
314  if (retval.empty()) {
315  retval = "(QEditor::CodecUpdatePolicy)" + boost::lexical_cast<std::string>(i);
316  } else {
317  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
318  retval = retval.substr(strlen(strip));
319  if (canonic)
320  retval = "QEditor::CodecUpdatePolicy::" + retval;
321  }
322  return retval;
323  }
324 
325  const std::vector<int64_t>& stringifyQEditorCodecUpdatePolicy() {
327  }
328 }
329 
330 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
331 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 74
332 namespace stringify { namespace QEditor {
333  const char* EditFlag(int64_t i) {
334  switch (i) {
335  case 0L: return "None";
336  case 1L: return "Overwrite";
337  case 2L: return "CursorOn";
338  case 4L: return "ReadOnly";
339  case 8L: return "MousePressed";
340  case 16L: return "MaybeDrag";
341  case 32L: return "Selection";
342  case 64L: return "Persistent";
343  case 128L: return "Multiline";
344  case 256L: return "FoldedCursor";
345  case 4095L: return "Internal";
346  case 4096L: return "LineWrap";
347  case 65536L: return "CtrlNavigation";
348  case 131072L: return "CursorJumpPastWrap";
349  case 1048576L: return "ReplaceTabs";
350  case 2097152L: return "RemoveTrailing";
351  case 4194304L: return "PreserveTrailingIndent";
352  case 16777216L: return "AutoCloseChars";
353  case 33554432L: return "AutoIndent";
354  case 4294963200L: return "Accessible";
355  default: return "";
356  }
357  }
358 
359  std::string EditFlag(int64_t i, const std::string &strip) {
360  std::string s = EditFlag(i);
361  if (s.empty())
362  s = "(QEditor::EditFlag)" + boost::lexical_cast<std::string>(i);
363  if (boost::starts_with(s, strip))
364  s = s.substr(strip.size());
365  return s;
366  }
367 
368  const std::vector<int64_t>& EditFlag() {
369  static const int64_t values[] = {
370  0L,
371  1L,
372  2L,
373  4L,
374  8L,
375  16L,
376  32L,
377  64L,
378  128L,
379  256L,
380  4095L,
381  4096L,
382  65536L,
383  131072L,
384  1048576L,
385  2097152L,
386  4194304L,
387  16777216L,
388  33554432L,
389  4294963200L
390  };
391  static const std::vector<int64_t> retval(values, values + 20);
392  return retval;
393  }
394 
395 }}
396 
397 namespace Rose {
398  std::string stringifyQEditorEditFlag(int64_t i, const char *strip, bool canonic) {
399  std::string retval = stringify::QEditor::EditFlag(i);
400  if (retval.empty()) {
401  retval = "(QEditor::EditFlag)" + boost::lexical_cast<std::string>(i);
402  } else {
403  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
404  retval = retval.substr(strlen(strip));
405  if (canonic)
406  retval = "QEditor::EditFlag::" + retval;
407  }
408  return retval;
409  }
410 
411  const std::vector<int64_t>& stringifyQEditorEditFlag() {
413  }
414 }
415 
416 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
417 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 493
418 namespace stringify { namespace QEditor {
419  const char* SaveState(int64_t i) {
420  switch (i) {
421  case 0L: return "Undefined";
422  case 1L: return "Saving";
423  case 2L: return "Saved";
424  case 3L: return "Conflict";
425  default: return "";
426  }
427  }
428 
429  std::string SaveState(int64_t i, const std::string &strip) {
430  std::string s = SaveState(i);
431  if (s.empty())
432  s = "(QEditor::SaveState)" + boost::lexical_cast<std::string>(i);
433  if (boost::starts_with(s, strip))
434  s = s.substr(strip.size());
435  return s;
436  }
437 
438  const std::vector<int64_t>& SaveState() {
439  static const int64_t values[] = {
440  0L,
441  1L,
442  2L,
443  3L
444  };
445  static const std::vector<int64_t> retval(values, values + 4);
446  return retval;
447  }
448 
449 }}
450 
451 namespace Rose {
452  std::string stringifyQEditorSaveState(int64_t i, const char *strip, bool canonic) {
453  std::string retval = stringify::QEditor::SaveState(i);
454  if (retval.empty()) {
455  retval = "(QEditor::SaveState)" + boost::lexical_cast<std::string>(i);
456  } else {
457  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
458  retval = retval.substr(strlen(strip));
459  if (canonic)
460  retval = "QEditor::SaveState::" + retval;
461  }
462  return retval;
463  }
464 
465  const std::vector<int64_t>& stringifyQEditorSaveState() {
467  }
468 }
469 
470 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
471 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 41
472 namespace stringify { namespace QNFAAction {
473  const char* QNFAAction_(int64_t i) {
474  switch (i) {
475  case 0L: return "NoAction";
476  case 4095L: return "FormatMask";
477  case 16773120L: return "ParenMask";
478  case 16777216L: return "Highlight";
479  case 33554432L: return "Indent";
480  case 67108864L: return "ParenOpen";
481  case 134217728L: return "ParenClose";
482  case 268435456L: return "MatchParen";
483  case 536870912L: return "Fold";
484  case 1073741824L: return "Ambiguous";
485  case 2147483648L: return "Content";
486  default: return "";
487  }
488  }
489 
490  std::string QNFAAction_(int64_t i, const std::string &strip) {
491  std::string s = QNFAAction_(i);
492  if (s.empty())
493  s = "(QNFAAction::QNFAAction_)" + boost::lexical_cast<std::string>(i);
494  if (boost::starts_with(s, strip))
495  s = s.substr(strip.size());
496  return s;
497  }
498 
499  const std::vector<int64_t>& QNFAAction_() {
500  static const int64_t values[] = {
501  0L,
502  4095L,
503  16773120L,
504  16777216L,
505  33554432L,
506  67108864L,
507  134217728L,
508  268435456L,
509  536870912L,
510  1073741824L,
511  2147483648L
512  };
513  static const std::vector<int64_t> retval(values, values + 11);
514  return retval;
515  }
516 
517 }}
518 
519 namespace Rose {
520  std::string stringifyQNFAActionQNFAAction_(int64_t i, const char *strip, bool canonic) {
521  std::string retval = stringify::QNFAAction::QNFAAction_(i);
522  if (retval.empty()) {
523  retval = "(QNFAAction::QNFAAction_)" + boost::lexical_cast<std::string>(i);
524  } else {
525  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
526  retval = retval.substr(strlen(strip));
527  if (canonic)
528  retval = "QNFAAction::QNFAAction_::" + retval;
529  }
530  return retval;
531  }
532 
533  const std::vector<int64_t>& stringifyQNFAActionQNFAAction_() {
535  }
536 }
537 
538 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
539 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 129
540 namespace stringify { namespace QNFADefinition { namespace PMatch {
541  const char* Type(int64_t i) {
542  switch (i) {
543  case 0L: return "Invalid";
544  case 1L: return "Match";
545  case 2L: return "Mismatch";
546  default: return "";
547  }
548  }
549 
550  std::string Type(int64_t i, const std::string &strip) {
551  std::string s = Type(i);
552  if (s.empty())
553  s = "(QNFADefinition::PMatch::Type)" + boost::lexical_cast<std::string>(i);
554  if (boost::starts_with(s, strip))
555  s = s.substr(strip.size());
556  return s;
557  }
558 
559  const std::vector<int64_t>& Type() {
560  static const int64_t values[] = {
561  0L,
562  1L,
563  2L
564  };
565  static const std::vector<int64_t> retval(values, values + 3);
566  return retval;
567  }
568 
569 }}}
570 
571 namespace Rose {
572  std::string stringifyQNFADefinitionPMatchType(int64_t i, const char *strip, bool canonic) {
573  std::string retval = stringify::QNFADefinition::PMatch::Type(i);
574  if (retval.empty()) {
575  retval = "(QNFADefinition::PMatch::Type)" + boost::lexical_cast<std::string>(i);
576  } else {
577  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
578  retval = retval.substr(strlen(strip));
579  if (canonic)
580  retval = "QNFADefinition::PMatch::Type::" + retval;
581  }
582  return retval;
583  }
584 
585  const std::vector<int64_t>& stringifyQNFADefinitionPMatchType() {
587  }
588 }
589 
590 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
591 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 42
592 namespace stringify {
593  const char* NFAType(int64_t i) {
594  switch (i) {
595  case 0L: return "Char";
596  case 1L: return "Match";
597  case 2L: return "CxtBeg";
598  case 3L: return "ContextBegin";
599  case 4L: return "CxtEnd";
600  case 5L: return "ContextEnd";
601  case 8L: return "CxtEsc";
602  case 9L: return "EscapeSeq";
603  case 16L: return "Escaped";
604  case 32L: return "Exclusive";
605  case 64L: return "StayOnLine";
606  case 128L: return "Reserved";
607  default: return "";
608  }
609  }
610 
611  std::string NFAType(int64_t i, const std::string &strip) {
612  std::string s = NFAType(i);
613  if (s.empty())
614  s = "(NFAType)" + boost::lexical_cast<std::string>(i);
615  if (boost::starts_with(s, strip))
616  s = s.substr(strip.size());
617  return s;
618  }
619 
620  const std::vector<int64_t>& NFAType() {
621  static const int64_t values[] = {
622  0L,
623  1L,
624  2L,
625  3L,
626  4L,
627  5L,
628  8L,
629  9L,
630  16L,
631  32L,
632  64L,
633  128L
634  };
635  static const std::vector<int64_t> retval(values, values + 12);
636  return retval;
637  }
638 
639 }
640 
641 namespace Rose {
642  std::string stringifyNFAType(int64_t i, const char *strip, bool canonic) {
643  std::string retval = stringify::NFAType(i);
644  if (retval.empty()) {
645  retval = "(NFAType)" + boost::lexical_cast<std::string>(i);
646  } else {
647  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
648  retval = retval.substr(strlen(strip));
649  if (canonic)
650  retval = "NFAType::" + retval;
651  }
652  return retval;
653  }
654 
655  const std::vector<int64_t>& stringifyNFAType() {
656  return stringify::NFAType();
657  }
658 }
659 
660 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
661 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 63
662 namespace stringify {
663  const char* NFAAssertion(int64_t i) {
664  switch (i) {
665  case 0L: return "NoAssertion";
666  case 1L: return "ZeroOrOne";
667  case 2L: return "ZeroOrMore";
668  case 4L: return "OneOrMore";
669  case 8L: return "WordStart";
670  case 16L: return "WordEnd";
671  case 32L: return "Word";
672  case 64L: return "NonWord";
673  case 128L: return "Digit";
674  case 256L: return "NonDigit";
675  case 512L: return "Space";
676  case 1024L: return "NonSpace";
677  case 2048L: return "CaseSensitive";
678  default: return "";
679  }
680  }
681 
682  std::string NFAAssertion(int64_t i, const std::string &strip) {
683  std::string s = NFAAssertion(i);
684  if (s.empty())
685  s = "(NFAAssertion)" + boost::lexical_cast<std::string>(i);
686  if (boost::starts_with(s, strip))
687  s = s.substr(strip.size());
688  return s;
689  }
690 
691  const std::vector<int64_t>& NFAAssertion() {
692  static const int64_t values[] = {
693  0L,
694  1L,
695  2L,
696  4L,
697  8L,
698  16L,
699  32L,
700  64L,
701  128L,
702  256L,
703  512L,
704  1024L,
705  2048L
706  };
707  static const std::vector<int64_t> retval(values, values + 13);
708  return retval;
709  }
710 
711 }
712 
713 namespace Rose {
714  std::string stringifyNFAAssertion(int64_t i, const char *strip, bool canonic) {
715  std::string retval = stringify::NFAAssertion(i);
716  if (retval.empty()) {
717  retval = "(NFAAssertion)" + boost::lexical_cast<std::string>(i);
718  } else {
719  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
720  retval = retval.substr(strlen(strip));
721  if (canonic)
722  retval = "NFAAssertion::" + retval;
723  }
724  return retval;
725  }
726 
727  const std::vector<int64_t>& stringifyNFAAssertion() {
728  return stringify::NFAAssertion();
729  }
730 }
731 
732 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
733 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 38
734 namespace stringify { namespace QParenthesis {
735  const char* Role(int64_t i) {
736  switch (i) {
737  case 1L: return "Open";
738  case 2L: return "Close";
739  case 4L: return "Indent";
740  case 8L: return "Fold";
741  case 16L: return "Match";
742  default: return "";
743  }
744  }
745 
746  std::string Role(int64_t i, const std::string &strip) {
747  std::string s = Role(i);
748  if (s.empty())
749  s = "(QParenthesis::Role)" + boost::lexical_cast<std::string>(i);
750  if (boost::starts_with(s, strip))
751  s = s.substr(strip.size());
752  return s;
753  }
754 
755  const std::vector<int64_t>& Role() {
756  static const int64_t values[] = {
757  1L,
758  2L,
759  4L,
760  8L,
761  16L
762  };
763  static const std::vector<int64_t> retval(values, values + 5);
764  return retval;
765  }
766 
767 }}
768 
769 namespace Rose {
770  std::string stringifyQParenthesisRole(int64_t i, const char *strip, bool canonic) {
771  std::string retval = stringify::QParenthesis::Role(i);
772  if (retval.empty()) {
773  retval = "(QParenthesis::Role)" + boost::lexical_cast<std::string>(i);
774  } else {
775  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
776  retval = retval.substr(strlen(strip));
777  if (canonic)
778  retval = "QParenthesis::Role::" + retval;
779  }
780  return retval;
781  }
782 
783  const std::vector<int64_t>& stringifyQParenthesisRole() {
785  }
786 }
787 
788 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
789 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 69
790 namespace stringify { namespace QDocumentLine {
791  const char* State(int64_t i) {
792  switch (i) {
793  case 0L: return "None";
794  case 1L: return "Hidden";
795  case 2L: return "CollapsedBlockStart";
796  case 4L: return "CollapsedBlockEnd";
797  case 16L: return "LayoutDirty";
798  case 32L: return "FormatsApplied";
799  default: return "";
800  }
801  }
802 
803  std::string State(int64_t i, const std::string &strip) {
804  std::string s = State(i);
805  if (s.empty())
806  s = "(QDocumentLine::State)" + boost::lexical_cast<std::string>(i);
807  if (boost::starts_with(s, strip))
808  s = s.substr(strip.size());
809  return s;
810  }
811 
812  const std::vector<int64_t>& State() {
813  static const int64_t values[] = {
814  0L,
815  1L,
816  2L,
817  4L,
818  16L,
819  32L
820  };
821  static const std::vector<int64_t> retval(values, values + 6);
822  return retval;
823  }
824 
825 }}
826 
827 namespace Rose {
828  std::string stringifyQDocumentLineState(int64_t i, const char *strip, bool canonic) {
829  std::string retval = stringify::QDocumentLine::State(i);
830  if (retval.empty()) {
831  retval = "(QDocumentLine::State)" + boost::lexical_cast<std::string>(i);
832  } else {
833  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
834  retval = retval.substr(strlen(strip));
835  if (canonic)
836  retval = "QDocumentLine::State::" + retval;
837  }
838  return retval;
839  }
840 
841  const std::vector<int64_t>& stringifyQDocumentLineState() {
843  }
844 }
845 
846 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
847 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcommand.h line 37
848 namespace stringify { namespace QDocumentCommand {
849  const char* Command(int64_t i) {
850  switch (i) {
851  case 0L: return "None";
852  case 1L: return "Insert";
853  case 2L: return "Erase";
854  case 3L: return "Replace";
855  case 4L: return "Custom";
856  default: return "";
857  }
858  }
859 
860  std::string Command(int64_t i, const std::string &strip) {
861  std::string s = Command(i);
862  if (s.empty())
863  s = "(QDocumentCommand::Command)" + boost::lexical_cast<std::string>(i);
864  if (boost::starts_with(s, strip))
865  s = s.substr(strip.size());
866  return s;
867  }
868 
869  const std::vector<int64_t>& Command() {
870  static const int64_t values[] = {
871  0L,
872  1L,
873  2L,
874  3L,
875  4L
876  };
877  static const std::vector<int64_t> retval(values, values + 5);
878  return retval;
879  }
880 
881 }}
882 
883 namespace Rose {
884  std::string stringifyQDocumentCommandCommand(int64_t i, const char *strip, bool canonic) {
885  std::string retval = stringify::QDocumentCommand::Command(i);
886  if (retval.empty()) {
887  retval = "(QDocumentCommand::Command)" + boost::lexical_cast<std::string>(i);
888  } else {
889  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
890  retval = retval.substr(strlen(strip));
891  if (canonic)
892  retval = "QDocumentCommand::Command::" + retval;
893  }
894  return retval;
895  }
896 
897  const std::vector<int64_t>& stringifyQDocumentCommandCommand() {
899  }
900 }
901 
902 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
903 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 39
904 namespace stringify { namespace QDocumentCursor {
905  const char* MoveFlag(int64_t i) {
906  switch (i) {
907  case 0L: return "MoveAnchor";
908  case 1L: return "KeepAnchor";
909  case 2L: return "ThroughWrap";
910  default: return "";
911  }
912  }
913 
914  std::string MoveFlag(int64_t i, const std::string &strip) {
915  std::string s = MoveFlag(i);
916  if (s.empty())
917  s = "(QDocumentCursor::MoveFlag)" + boost::lexical_cast<std::string>(i);
918  if (boost::starts_with(s, strip))
919  s = s.substr(strip.size());
920  return s;
921  }
922 
923  const std::vector<int64_t>& MoveFlag() {
924  static const int64_t values[] = {
925  0L,
926  1L,
927  2L
928  };
929  static const std::vector<int64_t> retval(values, values + 3);
930  return retval;
931  }
932 
933 }}
934 
935 namespace Rose {
936  std::string stringifyQDocumentCursorMoveFlag(int64_t i, const char *strip, bool canonic) {
937  std::string retval = stringify::QDocumentCursor::MoveFlag(i);
938  if (retval.empty()) {
939  retval = "(QDocumentCursor::MoveFlag)" + boost::lexical_cast<std::string>(i);
940  } else {
941  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
942  retval = retval.substr(strlen(strip));
943  if (canonic)
944  retval = "QDocumentCursor::MoveFlag::" + retval;
945  }
946  return retval;
947  }
948 
949  const std::vector<int64_t>& stringifyQDocumentCursorMoveFlag() {
951  }
952 }
953 
954 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
955 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 48
956 namespace stringify { namespace QDocumentCursor {
957  const char* MoveOperation(int64_t i) {
958  switch (i) {
959  case 0L: return "NoMove";
960  case 1L: return "Up";
961  case 2L: return "Down";
962  case 3L: return "Left";
963  case 4L: return "Right";
964  case 5L: return "Start";
965  case 6L: return "StartOfLine";
966  case 7L: return "StartOfWord";
967  case 8L: return "PreviousBlock";
968  case 9L: return "PreviousWord";
969  case 10L: return "WordLeft";
970  case 11L: return "WordRight";
971  case 12L: return "End";
972  case 13L: return "EndOfLine";
973  case 14L: return "EndOfWord";
974  case 15L: return "NextWord";
975  case 16L: return "NextBlock";
976  default: return "";
977  }
978  }
979 
980  std::string MoveOperation(int64_t i, const std::string &strip) {
981  std::string s = MoveOperation(i);
982  if (s.empty())
983  s = "(QDocumentCursor::MoveOperation)" + boost::lexical_cast<std::string>(i);
984  if (boost::starts_with(s, strip))
985  s = s.substr(strip.size());
986  return s;
987  }
988 
989  const std::vector<int64_t>& MoveOperation() {
990  static const int64_t values[] = {
991  0L,
992  1L,
993  2L,
994  3L,
995  4L,
996  5L,
997  6L,
998  7L,
999  8L,
1000  9L,
1001  10L,
1002  11L,
1003  12L,
1004  13L,
1005  14L,
1006  15L,
1007  16L
1008  };
1009  static const std::vector<int64_t> retval(values, values + 17);
1010  return retval;
1011  }
1012 
1013 }}
1014 
1015 namespace Rose {
1016  std::string stringifyQDocumentCursorMoveOperation(int64_t i, const char *strip, bool canonic) {
1017  std::string retval = stringify::QDocumentCursor::MoveOperation(i);
1018  if (retval.empty()) {
1019  retval = "(QDocumentCursor::MoveOperation)" + boost::lexical_cast<std::string>(i);
1020  } else {
1021  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1022  retval = retval.substr(strlen(strip));
1023  if (canonic)
1024  retval = "QDocumentCursor::MoveOperation::" + retval;
1025  }
1026  return retval;
1027  }
1028 
1029  const std::vector<int64_t>& stringifyQDocumentCursorMoveOperation() {
1031  }
1032 }
1033 
1034 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1035 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 75
1036 namespace stringify { namespace QDocumentCursor {
1037  const char* SelectionType(int64_t i) {
1038  switch (i) {
1039  case 0L: return "WordUnderCursor";
1040  case 1L: return "LineUnderCursor";
1041  default: return "";
1042  }
1043  }
1044 
1045  std::string SelectionType(int64_t i, const std::string &strip) {
1046  std::string s = SelectionType(i);
1047  if (s.empty())
1048  s = "(QDocumentCursor::SelectionType)" + boost::lexical_cast<std::string>(i);
1049  if (boost::starts_with(s, strip))
1050  s = s.substr(strip.size());
1051  return s;
1052  }
1053 
1054  const std::vector<int64_t>& SelectionType() {
1055  static const int64_t values[] = {
1056  0L,
1057  1L
1058  };
1059  static const std::vector<int64_t> retval(values, values + 2);
1060  return retval;
1061  }
1062 
1063 }}
1064 
1065 namespace Rose {
1066  std::string stringifyQDocumentCursorSelectionType(int64_t i, const char *strip, bool canonic) {
1067  std::string retval = stringify::QDocumentCursor::SelectionType(i);
1068  if (retval.empty()) {
1069  retval = "(QDocumentCursor::SelectionType)" + boost::lexical_cast<std::string>(i);
1070  } else {
1071  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1072  retval = retval.substr(strlen(strip));
1073  if (canonic)
1074  retval = "QDocumentCursor::SelectionType::" + retval;
1075  }
1076  return retval;
1077  }
1078 
1079  const std::vector<int64_t>& stringifyQDocumentCursorSelectionType() {
1081  }
1082 }
1083 
1084 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1085 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 84
1086 namespace stringify { namespace QDocument {
1087  const char* LineEnding(int64_t i) {
1088  switch (i) {
1089  case 0L: return "Conservative";
1090  case 1L: return "Local";
1091  case 2L: return "Unix";
1092  case 3L: return "Windows";
1093  case 4L: return "Mac";
1094  default: return "";
1095  }
1096  }
1097 
1098  std::string LineEnding(int64_t i, const std::string &strip) {
1099  std::string s = LineEnding(i);
1100  if (s.empty())
1101  s = "(QDocument::LineEnding)" + boost::lexical_cast<std::string>(i);
1102  if (boost::starts_with(s, strip))
1103  s = s.substr(strip.size());
1104  return s;
1105  }
1106 
1107  const std::vector<int64_t>& LineEnding() {
1108  static const int64_t values[] = {
1109  0L,
1110  1L,
1111  2L,
1112  3L,
1113  4L
1114  };
1115  static const std::vector<int64_t> retval(values, values + 5);
1116  return retval;
1117  }
1118 
1119 }}
1120 
1121 namespace Rose {
1122  std::string stringifyQDocumentLineEnding(int64_t i, const char *strip, bool canonic) {
1123  std::string retval = stringify::QDocument::LineEnding(i);
1124  if (retval.empty()) {
1125  retval = "(QDocument::LineEnding)" + boost::lexical_cast<std::string>(i);
1126  } else {
1127  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1128  retval = retval.substr(strlen(strip));
1129  if (canonic)
1130  retval = "QDocument::LineEnding::" + retval;
1131  }
1132  return retval;
1133  }
1134 
1135  const std::vector<int64_t>& stringifyQDocumentLineEnding() {
1137  }
1138 }
1139 
1140 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1141 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 93
1142 namespace stringify { namespace QDocument {
1143  const char* TextProcessing(int64_t i) {
1144  switch (i) {
1145  case 1L: return "RemoveTrailingWS";
1146  case 2L: return "PreserveIndent";
1147  case 4L: return "RestoreTrailingIndent";
1148  default: return "";
1149  }
1150  }
1151 
1152  std::string TextProcessing(int64_t i, const std::string &strip) {
1153  std::string s = TextProcessing(i);
1154  if (s.empty())
1155  s = "(QDocument::TextProcessing)" + boost::lexical_cast<std::string>(i);
1156  if (boost::starts_with(s, strip))
1157  s = s.substr(strip.size());
1158  return s;
1159  }
1160 
1161  const std::vector<int64_t>& TextProcessing() {
1162  static const int64_t values[] = {
1163  1L,
1164  2L,
1165  4L
1166  };
1167  static const std::vector<int64_t> retval(values, values + 3);
1168  return retval;
1169  }
1170 
1171 }}
1172 
1173 namespace Rose {
1174  std::string stringifyQDocumentTextProcessing(int64_t i, const char *strip, bool canonic) {
1175  std::string retval = stringify::QDocument::TextProcessing(i);
1176  if (retval.empty()) {
1177  retval = "(QDocument::TextProcessing)" + boost::lexical_cast<std::string>(i);
1178  } else {
1179  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1180  retval = retval.substr(strlen(strip));
1181  if (canonic)
1182  retval = "QDocument::TextProcessing::" + retval;
1183  }
1184  return retval;
1185  }
1186 
1187  const std::vector<int64_t>& stringifyQDocumentTextProcessing() {
1189  }
1190 }
1191 
1192 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1193 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 100
1194 namespace stringify { namespace QDocument {
1195  const char* WhiteSpaceFlag(int64_t i) {
1196  switch (i) {
1197  case 0L: return "ShowNone";
1198  case 1L: return "ShowTrailing";
1199  case 2L: return "ShowLeading";
1200  case 4L: return "ShowTabs";
1201  default: return "";
1202  }
1203  }
1204 
1205  std::string WhiteSpaceFlag(int64_t i, const std::string &strip) {
1206  std::string s = WhiteSpaceFlag(i);
1207  if (s.empty())
1208  s = "(QDocument::WhiteSpaceFlag)" + boost::lexical_cast<std::string>(i);
1209  if (boost::starts_with(s, strip))
1210  s = s.substr(strip.size());
1211  return s;
1212  }
1213 
1214  const std::vector<int64_t>& WhiteSpaceFlag() {
1215  static const int64_t values[] = {
1216  0L,
1217  1L,
1218  2L,
1219  4L
1220  };
1221  static const std::vector<int64_t> retval(values, values + 4);
1222  return retval;
1223  }
1224 
1225 }}
1226 
1227 namespace Rose {
1228  std::string stringifyQDocumentWhiteSpaceFlag(int64_t i, const char *strip, bool canonic) {
1229  std::string retval = stringify::QDocument::WhiteSpaceFlag(i);
1230  if (retval.empty()) {
1231  retval = "(QDocument::WhiteSpaceFlag)" + boost::lexical_cast<std::string>(i);
1232  } else {
1233  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1234  retval = retval.substr(strlen(strip));
1235  if (canonic)
1236  retval = "QDocument::WhiteSpaceFlag::" + retval;
1237  }
1238  return retval;
1239  }
1240 
1241  const std::vector<int64_t>& stringifyQDocumentWhiteSpaceFlag() {
1243  }
1244 }
1245 
1246 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1247 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentsearch.h line 40
1248 namespace stringify { namespace QDocumentSearch {
1249  const char* Option(int64_t i) {
1250  switch (i) {
1251  case 1L: return "WholeWords";
1252  case 2L: return "CaseSensitive";
1253  case 4L: return "RegExp";
1254  case 8L: return "Replace";
1255  case 16L: return "Prompt";
1256  case 32L: return "Silent";
1257  case 64L: return "HighlightAll";
1258  default: return "";
1259  }
1260  }
1261 
1262  std::string Option(int64_t i, const std::string &strip) {
1263  std::string s = Option(i);
1264  if (s.empty())
1265  s = "(QDocumentSearch::Option)" + boost::lexical_cast<std::string>(i);
1266  if (boost::starts_with(s, strip))
1267  s = s.substr(strip.size());
1268  return s;
1269  }
1270 
1271  const std::vector<int64_t>& Option() {
1272  static const int64_t values[] = {
1273  1L,
1274  2L,
1275  4L,
1276  8L,
1277  16L,
1278  32L,
1279  64L
1280  };
1281  static const std::vector<int64_t> retval(values, values + 7);
1282  return retval;
1283  }
1284 
1285 }}
1286 
1287 namespace Rose {
1288  std::string stringifyQDocumentSearchOption(int64_t i, const char *strip, bool canonic) {
1289  std::string retval = stringify::QDocumentSearch::Option(i);
1290  if (retval.empty()) {
1291  retval = "(QDocumentSearch::Option)" + boost::lexical_cast<std::string>(i);
1292  } else {
1293  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1294  retval = retval.substr(strlen(strip));
1295  if (canonic)
1296  retval = "QDocumentSearch::Option::" + retval;
1297  }
1298  return retval;
1299  }
1300 
1301  const std::vector<int64_t>& stringifyQDocumentSearchOption() {
1303  }
1304 }
1305 
1306 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1307 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor_p.h line 52
1308 namespace stringify { namespace QDocumentCursorHandle {
1309  const char* Flags(int64_t i) {
1310  switch (i) {
1311  case 1L: return "Silent";
1312  case 2L: return "ColumnMemory";
1313  case 4L: return "MoveWithinWrapped";
1314  default: return "";
1315  }
1316  }
1317 
1318  std::string Flags(int64_t i, const std::string &strip) {
1319  std::string s = Flags(i);
1320  if (s.empty())
1321  s = "(QDocumentCursorHandle::Flags)" + boost::lexical_cast<std::string>(i);
1322  if (boost::starts_with(s, strip))
1323  s = s.substr(strip.size());
1324  return s;
1325  }
1326 
1327  const std::vector<int64_t>& Flags() {
1328  static const int64_t values[] = {
1329  1L,
1330  2L,
1331  4L
1332  };
1333  static const std::vector<int64_t> retval(values, values + 3);
1334  return retval;
1335  }
1336 
1337 }}
1338 
1339 namespace Rose {
1340  std::string stringifyQDocumentCursorHandleFlags(int64_t i, const char *strip, bool canonic) {
1341  std::string retval = stringify::QDocumentCursorHandle::Flags(i);
1342  if (retval.empty()) {
1343  retval = "(QDocumentCursorHandle::Flags)" + boost::lexical_cast<std::string>(i);
1344  } else {
1345  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1346  retval = retval.substr(strlen(strip));
1347  if (canonic)
1348  retval = "QDocumentCursorHandle::Flags::" + retval;
1349  }
1350  return retval;
1351  }
1352 
1353  const std::vector<int64_t>& stringifyQDocumentCursorHandleFlags() {
1355  }
1356 }
1357 
1358 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1359 // /src/roseExtensions/qtWidgets/AstGraphWidget/DisplayEdge.h line 40
1360 namespace stringify { namespace DisplayEdge {
1361  const char* PaintMode(int64_t i) {
1362  switch (i) {
1363  case 0L: return "STRAIGHT";
1364  case 1L: return "RECTANGULAR";
1365  case 2L: return "BEZIER_QUAD";
1366  case 3L: return "BEZIER_CUBIC";
1367  default: return "";
1368  }
1369  }
1370 
1371  std::string PaintMode(int64_t i, const std::string &strip) {
1372  std::string s = PaintMode(i);
1373  if (s.empty())
1374  s = "(DisplayEdge::PaintMode)" + boost::lexical_cast<std::string>(i);
1375  if (boost::starts_with(s, strip))
1376  s = s.substr(strip.size());
1377  return s;
1378  }
1379 
1380  const std::vector<int64_t>& PaintMode() {
1381  static const int64_t values[] = {
1382  0L,
1383  1L,
1384  2L,
1385  3L
1386  };
1387  static const std::vector<int64_t> retval(values, values + 4);
1388  return retval;
1389  }
1390 
1391 }}
1392 
1393 namespace Rose {
1394  std::string stringifyDisplayEdgePaintMode(int64_t i, const char *strip, bool canonic) {
1395  std::string retval = stringify::DisplayEdge::PaintMode(i);
1396  if (retval.empty()) {
1397  retval = "(DisplayEdge::PaintMode)" + boost::lexical_cast<std::string>(i);
1398  } else {
1399  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1400  retval = retval.substr(strlen(strip));
1401  if (canonic)
1402  retval = "DisplayEdge::PaintMode::" + retval;
1403  }
1404  return retval;
1405  }
1406 
1407  const std::vector<int64_t>& stringifyDisplayEdgePaintMode() {
1409  }
1410 }
1411 
1412 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1413 // /src/roseExtensions/qtWidgets/TaskSystem/CompilerOutputWidget.h line 25
1414 namespace stringify { namespace CompilerOutputWidget {
1415  const char* PatternType(int64_t i) {
1416  switch (i) {
1417  case 0L: return "Unknown";
1418  case 1L: return "Warning";
1419  case 2L: return "Error";
1420  default: return "";
1421  }
1422  }
1423 
1424  std::string PatternType(int64_t i, const std::string &strip) {
1425  std::string s = PatternType(i);
1426  if (s.empty())
1427  s = "(CompilerOutputWidget::PatternType)" + boost::lexical_cast<std::string>(i);
1428  if (boost::starts_with(s, strip))
1429  s = s.substr(strip.size());
1430  return s;
1431  }
1432 
1433  const std::vector<int64_t>& PatternType() {
1434  static const int64_t values[] = {
1435  0L,
1436  1L,
1437  2L
1438  };
1439  static const std::vector<int64_t> retval(values, values + 3);
1440  return retval;
1441  }
1442 
1443 }}
1444 
1445 namespace Rose {
1446  std::string stringifyCompilerOutputWidgetPatternType(int64_t i, const char *strip, bool canonic) {
1447  std::string retval = stringify::CompilerOutputWidget::PatternType(i);
1448  if (retval.empty()) {
1449  retval = "(CompilerOutputWidget::PatternType)" + boost::lexical_cast<std::string>(i);
1450  } else {
1451  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1452  retval = retval.substr(strlen(strip));
1453  if (canonic)
1454  retval = "CompilerOutputWidget::PatternType::" + retval;
1455  }
1456  return retval;
1457  }
1458 
1459  const std::vector<int64_t>& stringifyCompilerOutputWidgetPatternType() {
1461  }
1462 }
1463 
1464 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1465 // /src/roseExtensions/qtWidgets/TaskSystem/TaskInterface.h line 25
1466 namespace stringify { namespace Task {
1467  const char* State(int64_t i) {
1468  switch (i) {
1469  case 0L: return "BEFORE_START";
1470  case 1L: return "RUNNING";
1471  case 2L: return "FINISHED_SUCCESS";
1472  case 3L: return "FINISHED_ERROR";
1473  default: return "";
1474  }
1475  }
1476 
1477  std::string State(int64_t i, const std::string &strip) {
1478  std::string s = State(i);
1479  if (s.empty())
1480  s = "(Task::State)" + boost::lexical_cast<std::string>(i);
1481  if (boost::starts_with(s, strip))
1482  s = s.substr(strip.size());
1483  return s;
1484  }
1485 
1486  const std::vector<int64_t>& State() {
1487  static const int64_t values[] = {
1488  0L,
1489  1L,
1490  2L,
1491  3L
1492  };
1493  static const std::vector<int64_t> retval(values, values + 4);
1494  return retval;
1495  }
1496 
1497 }}
1498 
1499 namespace Rose {
1500  std::string stringifyTaskState(int64_t i, const char *strip, bool canonic) {
1501  std::string retval = stringify::Task::State(i);
1502  if (retval.empty()) {
1503  retval = "(Task::State)" + boost::lexical_cast<std::string>(i);
1504  } else {
1505  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1506  retval = retval.substr(strlen(strip));
1507  if (canonic)
1508  retval = "Task::State::" + retval;
1509  }
1510  return retval;
1511  }
1512 
1513  const std::vector<int64_t>& stringifyTaskState() {
1514  return stringify::Task::State();
1515  }
1516 }
1517 
1518 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1519 // /src/roseExtensions/qtWidgets/ProjectManager/DependencyInfo.h line 20
1520 namespace stringify { namespace DependencyInfo {
1521  const char* State(int64_t i) {
1522  switch (i) {
1523  case 0L: return "VALID";
1524  case 1L: return "INVALID";
1525  case 2L: return "ERROR";
1526  default: return "";
1527  }
1528  }
1529 
1530  std::string State(int64_t i, const std::string &strip) {
1531  std::string s = State(i);
1532  if (s.empty())
1533  s = "(DependencyInfo::State)" + boost::lexical_cast<std::string>(i);
1534  if (boost::starts_with(s, strip))
1535  s = s.substr(strip.size());
1536  return s;
1537  }
1538 
1539  const std::vector<int64_t>& State() {
1540  static const int64_t values[] = {
1541  0L,
1542  1L,
1543  2L
1544  };
1545  static const std::vector<int64_t> retval(values, values + 3);
1546  return retval;
1547  }
1548 
1549 }}
1550 
1551 namespace Rose {
1552  std::string stringifyDependencyInfoState(int64_t i, const char *strip, bool canonic) {
1553  std::string retval = stringify::DependencyInfo::State(i);
1554  if (retval.empty()) {
1555  retval = "(DependencyInfo::State)" + boost::lexical_cast<std::string>(i);
1556  } else {
1557  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1558  retval = retval.substr(strlen(strip));
1559  if (canonic)
1560  retval = "DependencyInfo::State::" + retval;
1561  }
1562  return retval;
1563  }
1564 
1565  const std::vector<int64_t>& stringifyDependencyInfoState() {
1567  }
1568 }
1569 
1570 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1571 // /src/roseExtensions/qtWidgets/util/AstDisplayInfo.h line 14
1572 namespace stringify { namespace AstDisplayInfo {
1573  const char* NodeType(int64_t i) {
1574  switch (i) {
1575  case 0L: return "ROOT";
1576  case 1L: return "INCLUDE_ROOT";
1577  case 2L: return "SRC_FILE";
1578  case 3L: return "INCLUDE_FILE";
1579  case 4L: return "NAMESPACE";
1580  case 5L: return "CLASS";
1581  case 6L: return "FUNCTION";
1582  case 7L: return "LOOP";
1583  case 8L: return "UNKNOWN";
1584  default: return "";
1585  }
1586  }
1587 
1588  std::string NodeType(int64_t i, const std::string &strip) {
1589  std::string s = NodeType(i);
1590  if (s.empty())
1591  s = "(AstDisplayInfo::NodeType)" + boost::lexical_cast<std::string>(i);
1592  if (boost::starts_with(s, strip))
1593  s = s.substr(strip.size());
1594  return s;
1595  }
1596 
1597  const std::vector<int64_t>& NodeType() {
1598  static const int64_t values[] = {
1599  0L,
1600  1L,
1601  2L,
1602  3L,
1603  4L,
1604  5L,
1605  6L,
1606  7L,
1607  8L
1608  };
1609  static const std::vector<int64_t> retval(values, values + 9);
1610  return retval;
1611  }
1612 
1613 }}
1614 
1615 namespace Rose {
1616  std::string stringifyAstDisplayInfoNodeType(int64_t i, const char *strip, bool canonic) {
1617  std::string retval = stringify::AstDisplayInfo::NodeType(i);
1618  if (retval.empty()) {
1619  retval = "(AstDisplayInfo::NodeType)" + boost::lexical_cast<std::string>(i);
1620  } else {
1621  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1622  retval = retval.substr(strlen(strip));
1623  if (canonic)
1624  retval = "AstDisplayInfo::NodeType::" + retval;
1625  }
1626  return retval;
1627  }
1628 
1629  const std::vector<int64_t>& stringifyAstDisplayInfoNodeType() {
1631  }
1632 }
1633 
1634 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1635 // /src/roseExtensions/qtWidgets/QtGradientEditor/qtgradientwidget.cpp line 91
1636 namespace stringify { namespace QtGradientWidgetPrivate {
1637  const char* Handle(int64_t i) {
1638  switch (i) {
1639  case 0L: return "NoHandle";
1640  case 1L: return "StartLinearHandle";
1641  case 2L: return "EndLinearHandle";
1642  case 3L: return "CentralRadialHandle";
1643  case 4L: return "FocalRadialHandle";
1644  case 5L: return "RadiusRadialHandle";
1645  case 6L: return "CentralConicalHandle";
1646  case 7L: return "AngleConicalHandle";
1647  default: return "";
1648  }
1649  }
1650 
1651  std::string Handle(int64_t i, const std::string &strip) {
1652  std::string s = Handle(i);
1653  if (s.empty())
1654  s = "(QtGradientWidgetPrivate::Handle)" + boost::lexical_cast<std::string>(i);
1655  if (boost::starts_with(s, strip))
1656  s = s.substr(strip.size());
1657  return s;
1658  }
1659 
1660  const std::vector<int64_t>& Handle() {
1661  static const int64_t values[] = {
1662  0L,
1663  1L,
1664  2L,
1665  3L,
1666  4L,
1667  5L,
1668  6L,
1669  7L
1670  };
1671  static const std::vector<int64_t> retval(values, values + 8);
1672  return retval;
1673  }
1674 
1675 }}
1676 
1677 namespace Rose {
1678  std::string stringifyQtGradientWidgetPrivateHandle(int64_t i, const char *strip, bool canonic) {
1679  std::string retval = stringify::QtGradientWidgetPrivate::Handle(i);
1680  if (retval.empty()) {
1681  retval = "(QtGradientWidgetPrivate::Handle)" + boost::lexical_cast<std::string>(i);
1682  } else {
1683  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1684  retval = retval.substr(strlen(strip));
1685  if (canonic)
1686  retval = "QtGradientWidgetPrivate::Handle::" + retval;
1687  }
1688  return retval;
1689  }
1690 
1691  const std::vector<int64_t>& stringifyQtGradientWidgetPrivateHandle() {
1693  }
1694 }
1695 
1696 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1697 // /src/roseExtensions/qtWidgets/QtGradientEditor/qtcolorline.h line 62
1698 namespace stringify { namespace QtColorLine {
1699  const char* ColorComponent(int64_t i) {
1700  switch (i) {
1701  case 0L: return "Red";
1702  case 1L: return "Green";
1703  case 2L: return "Blue";
1704  case 3L: return "Hue";
1705  case 4L: return "Saturation";
1706  case 5L: return "Value";
1707  case 6L: return "Alpha";
1708  default: return "";
1709  }
1710  }
1711 
1712  std::string ColorComponent(int64_t i, const std::string &strip) {
1713  std::string s = ColorComponent(i);
1714  if (s.empty())
1715  s = "(QtColorLine::ColorComponent)" + boost::lexical_cast<std::string>(i);
1716  if (boost::starts_with(s, strip))
1717  s = s.substr(strip.size());
1718  return s;
1719  }
1720 
1721  const std::vector<int64_t>& ColorComponent() {
1722  static const int64_t values[] = {
1723  0L,
1724  1L,
1725  2L,
1726  3L,
1727  4L,
1728  5L,
1729  6L
1730  };
1731  static const std::vector<int64_t> retval(values, values + 7);
1732  return retval;
1733  }
1734 
1735 }}
1736 
1737 namespace Rose {
1738  std::string stringifyQtColorLineColorComponent(int64_t i, const char *strip, bool canonic) {
1739  std::string retval = stringify::QtColorLine::ColorComponent(i);
1740  if (retval.empty()) {
1741  retval = "(QtColorLine::ColorComponent)" + boost::lexical_cast<std::string>(i);
1742  } else {
1743  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1744  retval = retval.substr(strlen(strip));
1745  if (canonic)
1746  retval = "QtColorLine::ColorComponent::" + retval;
1747  }
1748  return retval;
1749  }
1750 
1751  const std::vector<int64_t>& stringifyQtColorLineColorComponent() {
1753  }
1754 }
1755 
1756 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1757 // /src/roseExtensions/failSafe/failSafePragma.h line 31
1758 namespace stringify { namespace FailSafe {
1759  const char* fail_safe_enum(int64_t i) {
1760  switch (i) {
1761  case 0L: return "e_unknown";
1762  case 1L: return "e_region";
1763  case 2L: return "e_status_predicate";
1764  case 3L: return "e_data_predicate";
1765  case 4L: return "e_tolerance";
1766  case 5L: return "e_double_redundancy";
1767  case 6L: return "e_triple_redundancy";
1768  case 7L: return "e_save";
1769  case 8L: return "e_assert";
1770  case 9L: return "e_specifier";
1771  case 10L: return "e_region_reference";
1772  case 11L: return "e_error";
1773  case 12L: return "e_violation";
1774  case 13L: return "e_recover";
1775  case 14L: return "e_pre";
1776  case 15L: return "e_post";
1777  case 16L: return "e_type_ET1";
1778  case 17L: return "e_type_ET2";
1779  case 18L: return "e_violation_NaN";
1780  case 19L: return "e_violation_SECDED";
1781  case 20L: return "e_violation_SEGFAULT";
1782  case 21L: return "e_violation_ANY";
1783  case 22L: return "e_not_failsafe";
1784  default: return "";
1785  }
1786  }
1787 
1788  std::string fail_safe_enum(int64_t i, const std::string &strip) {
1789  std::string s = fail_safe_enum(i);
1790  if (s.empty())
1791  s = "(FailSafe::fail_safe_enum)" + boost::lexical_cast<std::string>(i);
1792  if (boost::starts_with(s, strip))
1793  s = s.substr(strip.size());
1794  return s;
1795  }
1796 
1797  const std::vector<int64_t>& fail_safe_enum() {
1798  static const int64_t values[] = {
1799  0L,
1800  1L,
1801  2L,
1802  3L,
1803  4L,
1804  5L,
1805  6L,
1806  7L,
1807  8L,
1808  9L,
1809  10L,
1810  11L,
1811  12L,
1812  13L,
1813  14L,
1814  15L,
1815  16L,
1816  17L,
1817  18L,
1818  19L,
1819  20L,
1820  21L,
1821  22L
1822  };
1823  static const std::vector<int64_t> retval(values, values + 23);
1824  return retval;
1825  }
1826 
1827 }}
1828 
1829 namespace Rose {
1830  std::string stringifyFailSafe_fail_safe_enum(int64_t i, const char *strip, bool canonic) {
1831  std::string retval = stringify::FailSafe::fail_safe_enum(i);
1832  if (retval.empty()) {
1833  retval = "(FailSafe::fail_safe_enum)" + boost::lexical_cast<std::string>(i);
1834  } else {
1835  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1836  retval = retval.substr(strlen(strip));
1837  if (canonic)
1838  retval = "FailSafe::fail_safe_enum::" + retval;
1839  }
1840  return retval;
1841  }
1842 
1843  const std::vector<int64_t>& stringifyFailSafe_fail_safe_enum() {
1845  }
1846 }
1847 
1848 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1849 // /src/roseExtensions/dataStructureTraversal/exampleTest.C line 3
1850 namespace stringify {
1851  const char* controlEnum(int64_t i) {
1852  switch (i) {
1853  case 0L: return "BEGGINING_OF_ENUM";
1854  case 1L: return "typeInt";
1855  case 2L: return "typeChar";
1856  case 3L: return "typeTestStruct";
1857  case 4L: return "END_OF_ENUM";
1858  default: return "";
1859  }
1860  }
1861 
1862  std::string controlEnum(int64_t i, const std::string &strip) {
1863  std::string s = controlEnum(i);
1864  if (s.empty())
1865  s = "(controlEnum)" + boost::lexical_cast<std::string>(i);
1866  if (boost::starts_with(s, strip))
1867  s = s.substr(strip.size());
1868  return s;
1869  }
1870 
1871  const std::vector<int64_t>& controlEnum() {
1872  static const int64_t values[] = {
1873  0L,
1874  1L,
1875  2L,
1876  3L,
1877  4L
1878  };
1879  static const std::vector<int64_t> retval(values, values + 5);
1880  return retval;
1881  }
1882 
1883 }
1884 
1885 namespace Rose {
1886  std::string stringify_controlEnum(int64_t i, const char *strip, bool canonic) {
1887  std::string retval = stringify::controlEnum(i);
1888  if (retval.empty()) {
1889  retval = "(controlEnum)" + boost::lexical_cast<std::string>(i);
1890  } else {
1891  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1892  retval = retval.substr(strlen(strip));
1893  if (canonic)
1894  retval = "controlEnum::" + retval;
1895  }
1896  return retval;
1897  }
1898 
1899  const std::vector<int64_t>& stringify_controlEnum() {
1900  return stringify::controlEnum();
1901  }
1902 }
1903 
1904 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1905 // /src/roseExtensions/dataStructureTraversal/GenRepresentation.h line 23
1906 namespace stringify { namespace GenRepresentation {
1907  const char* TypeOfPrint(int64_t i) {
1908  switch (i) {
1909  case 0L: return "UnknownListElement";
1910  case 1L: return "Container";
1911  case 2L: return "Contained";
1912  case 3L: return "END_OF_LIST";
1913  default: return "";
1914  }
1915  }
1916 
1917  std::string TypeOfPrint(int64_t i, const std::string &strip) {
1918  std::string s = TypeOfPrint(i);
1919  if (s.empty())
1920  s = "(GenRepresentation::TypeOfPrint)" + boost::lexical_cast<std::string>(i);
1921  if (boost::starts_with(s, strip))
1922  s = s.substr(strip.size());
1923  return s;
1924  }
1925 
1926  const std::vector<int64_t>& TypeOfPrint() {
1927  static const int64_t values[] = {
1928  0L,
1929  1L,
1930  2L,
1931  3L
1932  };
1933  static const std::vector<int64_t> retval(values, values + 4);
1934  return retval;
1935  }
1936 
1937 }}
1938 
1939 namespace Rose {
1940  std::string stringifyGenRepresentationTypeOfPrint(int64_t i, const char *strip, bool canonic) {
1941  std::string retval = stringify::GenRepresentation::TypeOfPrint(i);
1942  if (retval.empty()) {
1943  retval = "(GenRepresentation::TypeOfPrint)" + boost::lexical_cast<std::string>(i);
1944  } else {
1945  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1946  retval = retval.substr(strlen(strip));
1947  if (canonic)
1948  retval = "GenRepresentation::TypeOfPrint::" + retval;
1949  }
1950  return retval;
1951  }
1952 
1953  const std::vector<int64_t>& stringifyGenRepresentationTypeOfPrint() {
1955  }
1956 }
1957 
1958 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1959 // /src/ROSETTA/src/grammar.h line 88
1960 namespace stringify {
1961  const char* ConstructParamEnum(int64_t i) {
1962  switch (i) {
1963  case 0L: return "NO_CONSTRUCTOR_PARAMETER";
1964  case 1L: return "CONSTRUCTOR_PARAMETER";
1965  default: return "";
1966  }
1967  }
1968 
1969  std::string ConstructParamEnum(int64_t i, const std::string &strip) {
1970  std::string s = ConstructParamEnum(i);
1971  if (s.empty())
1972  s = "(ConstructParamEnum)" + boost::lexical_cast<std::string>(i);
1973  if (boost::starts_with(s, strip))
1974  s = s.substr(strip.size());
1975  return s;
1976  }
1977 
1978  const std::vector<int64_t>& ConstructParamEnum() {
1979  static const int64_t values[] = {
1980  0L,
1981  1L
1982  };
1983  static const std::vector<int64_t> retval(values, values + 2);
1984  return retval;
1985  }
1986 
1987 }
1988 
1989 namespace Rose {
1990  std::string stringifyConstructParamEnum(int64_t i, const char *strip, bool canonic) {
1991  std::string retval = stringify::ConstructParamEnum(i);
1992  if (retval.empty()) {
1993  retval = "(ConstructParamEnum)" + boost::lexical_cast<std::string>(i);
1994  } else {
1995  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1996  retval = retval.substr(strlen(strip));
1997  if (canonic)
1998  retval = "ConstructParamEnum::" + retval;
1999  }
2000  return retval;
2001  }
2002 
2003  const std::vector<int64_t>& stringifyConstructParamEnum() {
2005  }
2006 }
2007 
2008 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2009 // /src/ROSETTA/src/grammar.h line 93
2010 namespace stringify {
2011  const char* BuildAccessEnum(int64_t i) {
2012  switch (i) {
2013  case 0L: return "NO_ACCESS_FUNCTIONS";
2014  case 1L: return "BUILD_ACCESS_FUNCTIONS";
2015  case 2L: return "BUILD_FLAG_ACCESS_FUNCTIONS";
2016  case 3L: return "BUILD_LIST_ACCESS_FUNCTIONS";
2017  default: return "";
2018  }
2019  }
2020 
2021  std::string BuildAccessEnum(int64_t i, const std::string &strip) {
2022  std::string s = BuildAccessEnum(i);
2023  if (s.empty())
2024  s = "(BuildAccessEnum)" + boost::lexical_cast<std::string>(i);
2025  if (boost::starts_with(s, strip))
2026  s = s.substr(strip.size());
2027  return s;
2028  }
2029 
2030  const std::vector<int64_t>& BuildAccessEnum() {
2031  static const int64_t values[] = {
2032  0L,
2033  1L,
2034  2L,
2035  3L
2036  };
2037  static const std::vector<int64_t> retval(values, values + 4);
2038  return retval;
2039  }
2040 
2041 }
2042 
2043 namespace Rose {
2044  std::string stringifyBuildAccessEnum(int64_t i, const char *strip, bool canonic) {
2045  std::string retval = stringify::BuildAccessEnum(i);
2046  if (retval.empty()) {
2047  retval = "(BuildAccessEnum)" + boost::lexical_cast<std::string>(i);
2048  } else {
2049  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2050  retval = retval.substr(strlen(strip));
2051  if (canonic)
2052  retval = "BuildAccessEnum::" + retval;
2053  }
2054  return retval;
2055  }
2056 
2057  const std::vector<int64_t>& stringifyBuildAccessEnum() {
2058  return stringify::BuildAccessEnum();
2059  }
2060 }
2061 
2062 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2063 // /src/ROSETTA/src/grammar.h line 101
2064 namespace stringify {
2065  const char* CopyConfigEnum(int64_t i) {
2066  switch (i) {
2067  case 0L: return "NO_COPY_DATA";
2068  case 1L: return "COPY_DATA";
2069  case 2L: return "CLONE_PTR";
2070  case 3L: return "CLONE_TREE";
2071  default: return "";
2072  }
2073  }
2074 
2075  std::string CopyConfigEnum(int64_t i, const std::string &strip) {
2076  std::string s = CopyConfigEnum(i);
2077  if (s.empty())
2078  s = "(CopyConfigEnum)" + boost::lexical_cast<std::string>(i);
2079  if (boost::starts_with(s, strip))
2080  s = s.substr(strip.size());
2081  return s;
2082  }
2083 
2084  const std::vector<int64_t>& CopyConfigEnum() {
2085  static const int64_t values[] = {
2086  0L,
2087  1L,
2088  2L,
2089  3L
2090  };
2091  static const std::vector<int64_t> retval(values, values + 4);
2092  return retval;
2093  }
2094 
2095 }
2096 
2097 namespace Rose {
2098  std::string stringifyCopyConfigEnum(int64_t i, const char *strip, bool canonic) {
2099  std::string retval = stringify::CopyConfigEnum(i);
2100  if (retval.empty()) {
2101  retval = "(CopyConfigEnum)" + boost::lexical_cast<std::string>(i);
2102  } else {
2103  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2104  retval = retval.substr(strlen(strip));
2105  if (canonic)
2106  retval = "CopyConfigEnum::" + retval;
2107  }
2108  return retval;
2109  }
2110 
2111  const std::vector<int64_t>& stringifyCopyConfigEnum() {
2112  return stringify::CopyConfigEnum();
2113  }
2114 }
2115 
2116 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2117 // /src/ROSETTA/src/grammar.h line 122
2118 namespace stringify {
2119  const char* TraversalEnum(int64_t i) {
2120  switch (i) {
2121  case 0L: return "DEF_TRAVERSAL";
2122  case 1L: return "NO_TRAVERSAL";
2123  default: return "";
2124  }
2125  }
2126 
2127  std::string TraversalEnum(int64_t i, const std::string &strip) {
2128  std::string s = TraversalEnum(i);
2129  if (s.empty())
2130  s = "(TraversalEnum)" + boost::lexical_cast<std::string>(i);
2131  if (boost::starts_with(s, strip))
2132  s = s.substr(strip.size());
2133  return s;
2134  }
2135 
2136  const std::vector<int64_t>& TraversalEnum() {
2137  static const int64_t values[] = {
2138  0L,
2139  1L
2140  };
2141  static const std::vector<int64_t> retval(values, values + 2);
2142  return retval;
2143  }
2144 
2145 }
2146 
2147 namespace Rose {
2148  std::string stringifyTraversalEnum(int64_t i, const char *strip, bool canonic) {
2149  std::string retval = stringify::TraversalEnum(i);
2150  if (retval.empty()) {
2151  retval = "(TraversalEnum)" + boost::lexical_cast<std::string>(i);
2152  } else {
2153  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2154  retval = retval.substr(strlen(strip));
2155  if (canonic)
2156  retval = "TraversalEnum::" + retval;
2157  }
2158  return retval;
2159  }
2160 
2161  const std::vector<int64_t>& stringifyTraversalEnum() {
2162  return stringify::TraversalEnum();
2163  }
2164 }
2165 
2166 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2167 // /src/ROSETTA/src/grammar.h line 127
2168 namespace stringify {
2169  const char* DeleteEnum(int64_t i) {
2170  switch (i) {
2171  case 0L: return "DEF_DELETE";
2172  case 1L: return "NO_DELETE";
2173  default: return "";
2174  }
2175  }
2176 
2177  std::string DeleteEnum(int64_t i, const std::string &strip) {
2178  std::string s = DeleteEnum(i);
2179  if (s.empty())
2180  s = "(DeleteEnum)" + boost::lexical_cast<std::string>(i);
2181  if (boost::starts_with(s, strip))
2182  s = s.substr(strip.size());
2183  return s;
2184  }
2185 
2186  const std::vector<int64_t>& DeleteEnum() {
2187  static const int64_t values[] = {
2188  0L,
2189  1L
2190  };
2191  static const std::vector<int64_t> retval(values, values + 2);
2192  return retval;
2193  }
2194 
2195 }
2196 
2197 namespace Rose {
2198  std::string stringifyDeleteEnum(int64_t i, const char *strip, bool canonic) {
2199  std::string retval = stringify::DeleteEnum(i);
2200  if (retval.empty()) {
2201  retval = "(DeleteEnum)" + boost::lexical_cast<std::string>(i);
2202  } else {
2203  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2204  retval = retval.substr(strlen(strip));
2205  if (canonic)
2206  retval = "DeleteEnum::" + retval;
2207  }
2208  return retval;
2209  }
2210 
2211  const std::vector<int64_t>& stringifyDeleteEnum() {
2212  return stringify::DeleteEnum();
2213  }
2214 }
2215 
2216 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2217 // /src/ROSETTA/src/AstNodeClass.h line 100
2218 namespace stringify { namespace AstNodeClass {
2219  const char* locationInTree(int64_t i) {
2220  switch (i) {
2221  case 0L: return "LOCAL_LIST";
2222  case 1L: return "SUBTREE_LIST";
2223  default: return "";
2224  }
2225  }
2226 
2227  std::string locationInTree(int64_t i, const std::string &strip) {
2228  std::string s = locationInTree(i);
2229  if (s.empty())
2230  s = "(AstNodeClass::locationInTree)" + boost::lexical_cast<std::string>(i);
2231  if (boost::starts_with(s, strip))
2232  s = s.substr(strip.size());
2233  return s;
2234  }
2235 
2236  const std::vector<int64_t>& locationInTree() {
2237  static const int64_t values[] = {
2238  0L,
2239  1L
2240  };
2241  static const std::vector<int64_t> retval(values, values + 2);
2242  return retval;
2243  }
2244 
2245 }}
2246 
2247 namespace Rose {
2248  std::string stringifyAstNodeClass_locationInTree(int64_t i, const char *strip, bool canonic) {
2249  std::string retval = stringify::AstNodeClass::locationInTree(i);
2250  if (retval.empty()) {
2251  retval = "(AstNodeClass::locationInTree)" + boost::lexical_cast<std::string>(i);
2252  } else {
2253  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2254  retval = retval.substr(strlen(strip));
2255  if (canonic)
2256  retval = "AstNodeClass::locationInTree::" + retval;
2257  }
2258  return retval;
2259  }
2260 
2261  const std::vector<int64_t>& stringifyAstNodeClass_locationInTree() {
2263  }
2264 }
2265 
2266 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2267 // /src/ROSETTA/src/AstNodeClass.h line 106
2268 namespace stringify { namespace AstNodeClass {
2269  const char* includeExcludeMechanism(int64_t i) {
2270  switch (i) {
2271  case 0L: return "INCLUDE_LIST";
2272  case 1L: return "EXCLUDE_LIST";
2273  default: return "";
2274  }
2275  }
2276 
2277  std::string includeExcludeMechanism(int64_t i, const std::string &strip) {
2278  std::string s = includeExcludeMechanism(i);
2279  if (s.empty())
2280  s = "(AstNodeClass::includeExcludeMechanism)" + boost::lexical_cast<std::string>(i);
2281  if (boost::starts_with(s, strip))
2282  s = s.substr(strip.size());
2283  return s;
2284  }
2285 
2286  const std::vector<int64_t>& includeExcludeMechanism() {
2287  static const int64_t values[] = {
2288  0L,
2289  1L
2290  };
2291  static const std::vector<int64_t> retval(values, values + 2);
2292  return retval;
2293  }
2294 
2295 }}
2296 
2297 namespace Rose {
2298  std::string stringifyAstNodeClass_includeExcludeMechanism(int64_t i, const char *strip, bool canonic) {
2299  std::string retval = stringify::AstNodeClass::includeExcludeMechanism(i);
2300  if (retval.empty()) {
2301  retval = "(AstNodeClass::includeExcludeMechanism)" + boost::lexical_cast<std::string>(i);
2302  } else {
2303  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2304  retval = retval.substr(strlen(strip));
2305  if (canonic)
2306  retval = "AstNodeClass::includeExcludeMechanism::" + retval;
2307  }
2308  return retval;
2309  }
2310 
2311  const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism() {
2313  }
2314 }
2315 
2316 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2317 // /src/ROSETTA/src/AstNodeClass.h line 309
2318 namespace stringify { namespace AstNodeClass {
2319  const char* TypeEvaluation(int64_t i) {
2320  switch (i) {
2321  case 0L: return "CHAR_POINTER";
2322  case 1L: return "CONST_CHAR_POINTER";
2323  case 2L: return "ATTACHEDPREPROCESSINGINFOTYPE";
2324  case 3L: return "ROSE_HASH_MULTIMAP";
2325  case 4L: return "ROSE_GRAPH_HASH_MULTIMAP";
2326  case 5L: return "ROSE_GRAPH_DIRECTED_EDGE_HASH_MULTIMAP";
2327  case 6L: return "ROSE_GRAPH_UNDIRECTED_EDGE_HASH_MULTIMAP";
2328  case 7L: return "ROSE_GRAPH_NODE_EDGE_HASH_MULTIMAP";
2329  case 8L: return "ROSE_GRAPH_INTEGER_NODE_HASH_MAP";
2330  case 9L: return "ROSE_GRAPH_INTEGER_EDGE_HASH_MAP";
2331  case 10L: return "ROSE_GRAPH_STRING_INTEGER_HASH_MULTIMAP";
2332  case 11L: return "ROSE_GRAPH_INTEGER_PAIR_EDGE_HASH_MULTIMAP";
2333  case 12L: return "ROSE_GRAPH_INTEGER_EDGE_HASH_MULTIMAP";
2334  case 13L: return "SGCLASS_POINTER";
2335  case 14L: return "ROSEATTRUBUTESLISTCONTAINER";
2336  case 15L: return "SGCLASS_POINTER_LIST";
2337  case 16L: return "SGCLASS_POINTER_VECTOR";
2338  case 17L: return "SGCLASS_POINTER_VECTOR_NAMED_LIST";
2339  case 18L: return "STL_CONTAINER";
2340  case 19L: return "STL_SET";
2341  case 20L: return "STL_MULTIMAP";
2342  case 21L: return "STL_MAP";
2343  case 22L: return "STRING";
2344  case 23L: return "SGNAME";
2345  case 24L: return "BIT_VECTOR";
2346  case 25L: return "MODIFIERCLASS";
2347  case 26L: return "MODIFIERCLASS_WITHOUTEASYSTORAGE";
2348  case 27L: return "ASTATTRIBUTEMECHANISM";
2349  case 28L: return "TO_HANDLE";
2350  case 29L: return "OSTREAM";
2351  case 30L: return "ENUM_TYPE";
2352  case 31L: return "BASIC_DATA_TYPE";
2353  case 32L: return "SKIP_TYPE";
2354  case 33L: return "SGCLASS_POINTER_LIST_POINTER";
2355  default: return "";
2356  }
2357  }
2358 
2359  std::string TypeEvaluation(int64_t i, const std::string &strip) {
2360  std::string s = TypeEvaluation(i);
2361  if (s.empty())
2362  s = "(AstNodeClass::TypeEvaluation)" + boost::lexical_cast<std::string>(i);
2363  if (boost::starts_with(s, strip))
2364  s = s.substr(strip.size());
2365  return s;
2366  }
2367 
2368  const std::vector<int64_t>& TypeEvaluation() {
2369  static const int64_t values[] = {
2370  0L,
2371  1L,
2372  2L,
2373  3L,
2374  4L,
2375  5L,
2376  6L,
2377  7L,
2378  8L,
2379  9L,
2380  10L,
2381  11L,
2382  12L,
2383  13L,
2384  14L,
2385  15L,
2386  16L,
2387  17L,
2388  18L,
2389  19L,
2390  20L,
2391  21L,
2392  22L,
2393  23L,
2394  24L,
2395  25L,
2396  26L,
2397  27L,
2398  28L,
2399  29L,
2400  30L,
2401  31L,
2402  32L,
2403  33L
2404  };
2405  static const std::vector<int64_t> retval(values, values + 34);
2406  return retval;
2407  }
2408 
2409 }}
2410 
2411 namespace Rose {
2412  std::string stringifyAstNodeClassTypeEvaluation(int64_t i, const char *strip, bool canonic) {
2413  std::string retval = stringify::AstNodeClass::TypeEvaluation(i);
2414  if (retval.empty()) {
2415  retval = "(AstNodeClass::TypeEvaluation)" + boost::lexical_cast<std::string>(i);
2416  } else {
2417  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2418  retval = retval.substr(strlen(strip));
2419  if (canonic)
2420  retval = "AstNodeClass::TypeEvaluation::" + retval;
2421  }
2422  return retval;
2423  }
2424 
2425  const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation() {
2427  }
2428 }
2429 
2430 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2431 // /src/ROSETTA/src/binaryInstruction.C line 2643
2432 namespace stringify { namespace SgAsmRiscOperation {
2433  const char* RiscOperator(int64_t i) {
2434  switch (i) {
2435  case 0L: return "OP_NONE";
2436  case 1L: return "OP_bottom";
2437  case 2L: return "OP_undefined";
2438  case 3L: return "OP_unspecified";
2439  case 4L: return "OP_filterCallTarget";
2440  case 5L: return "OP_filterReturnTarget";
2441  case 6L: return "OP_filterIndirectJumpTarget";
2442  case 7L: return "OP_hlt";
2443  case 8L: return "OP_cpuid";
2444  case 9L: return "OP_rdtsc";
2445  case 10L: return "OP_and_";
2446  case 11L: return "OP_or_";
2447  case 12L: return "OP_xor_";
2448  case 13L: return "OP_invert";
2449  case 14L: return "OP_extract";
2450  case 15L: return "OP_concat";
2451  case 16L: return "OP_leastSignificantSetBit";
2452  case 17L: return "OP_mostSignificantSetBit";
2453  case 18L: return "OP_rotateLeft";
2454  case 19L: return "OP_rotateRight";
2455  case 20L: return "OP_shiftLeft";
2456  case 21L: return "OP_shiftRight";
2457  case 22L: return "OP_shiftRightArithmetic";
2458  case 23L: return "OP_equalToZero";
2459  case 24L: return "OP_ite";
2460  case 25L: return "OP_isEqual";
2461  case 26L: return "OP_isNotEqual";
2462  case 27L: return "OP_isUnsignedLessThan";
2463  case 28L: return "OP_isUnsignedLessThanOrEqual";
2464  case 29L: return "OP_isUnsignedGreaterThan";
2465  case 30L: return "OP_isUnsignedGreaterThanOrEqual";
2466  case 31L: return "OP_isSignedLessThan";
2467  case 32L: return "OP_isSignedLessThanOrEqual";
2468  case 33L: return "OP_isSignedGreaterThan";
2469  case 34L: return "OP_isSignedGreaterThanOrEqual";
2470  case 35L: return "OP_unsignedExtend";
2471  case 36L: return "OP_signExtend";
2472  case 37L: return "OP_add";
2473  case 38L: return "OP_addCarries";
2474  case 39L: return "OP_subtract";
2475  case 40L: return "OP_negate";
2476  case 41L: return "OP_signedDivide";
2477  case 42L: return "OP_signedModulo";
2478  case 43L: return "OP_signedMultiply";
2479  case 44L: return "OP_unsignedDivide";
2480  case 45L: return "OP_unsignedModulo";
2481  case 46L: return "OP_unsignedMultiply";
2482  case 47L: return "OP_interrupt";
2483  case 48L: return "OP_readRegister";
2484  case 49L: return "OP_peekRegister";
2485  case 50L: return "OP_writeRegister";
2486  case 51L: return "OP_readMemory";
2487  case 52L: return "OP_peekMemory";
2488  case 53L: return "OP_writeMemory";
2489  case 54L: return "OP_N_OPERATORS";
2490  default: return "";
2491  }
2492  }
2493 
2494  std::string RiscOperator(int64_t i, const std::string &strip) {
2495  std::string s = RiscOperator(i);
2496  if (s.empty())
2497  s = "(SgAsmRiscOperation::RiscOperator)" + boost::lexical_cast<std::string>(i);
2498  if (boost::starts_with(s, strip))
2499  s = s.substr(strip.size());
2500  return s;
2501  }
2502 
2503  const std::vector<int64_t>& RiscOperator() {
2504  static const int64_t values[] = {
2505  0L,
2506  1L,
2507  2L,
2508  3L,
2509  4L,
2510  5L,
2511  6L,
2512  7L,
2513  8L,
2514  9L,
2515  10L,
2516  11L,
2517  12L,
2518  13L,
2519  14L,
2520  15L,
2521  16L,
2522  17L,
2523  18L,
2524  19L,
2525  20L,
2526  21L,
2527  22L,
2528  23L,
2529  24L,
2530  25L,
2531  26L,
2532  27L,
2533  28L,
2534  29L,
2535  30L,
2536  31L,
2537  32L,
2538  33L,
2539  34L,
2540  35L,
2541  36L,
2542  37L,
2543  38L,
2544  39L,
2545  40L,
2546  41L,
2547  42L,
2548  43L,
2549  44L,
2550  45L,
2551  46L,
2552  47L,
2553  48L,
2554  49L,
2555  50L,
2556  51L,
2557  52L,
2558  53L,
2559  54L
2560  };
2561  static const std::vector<int64_t> retval(values, values + 55);
2562  return retval;
2563  }
2564 
2565 }}
2566 
2567 namespace Rose {
2568  std::string stringifySgAsmRiscOperationRiscOperator(int64_t i, const char *strip, bool canonic) {
2569  std::string retval = stringify::SgAsmRiscOperation::RiscOperator(i);
2570  if (retval.empty()) {
2571  retval = "(SgAsmRiscOperation::RiscOperator)" + boost::lexical_cast<std::string>(i);
2572  } else {
2573  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2574  retval = retval.substr(strlen(strip));
2575  if (canonic)
2576  retval = "SgAsmRiscOperation::RiscOperator::" + retval;
2577  }
2578  return retval;
2579  }
2580 
2581  const std::vector<int64_t>& stringifySgAsmRiscOperationRiscOperator() {
2583  }
2584 }
2585 
2586 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2587 // /src/ROSETTA/src/binaryInstruction.C line 3459
2588 namespace stringify { namespace SgAsmFunction {
2589  const char* MayReturn(int64_t i) {
2590  switch (i) {
2591  case 0L: return "RET_UNKNOWN";
2592  case 1L: return "RET_NEVER";
2593  case 2L: return "RET_SOMETIMES";
2594  case 3L: return "RET_ALWAYS";
2595  default: return "";
2596  }
2597  }
2598 
2599  std::string MayReturn(int64_t i, const std::string &strip) {
2600  std::string s = MayReturn(i);
2601  if (s.empty())
2602  s = "(SgAsmFunction::MayReturn)" + boost::lexical_cast<std::string>(i);
2603  if (boost::starts_with(s, strip))
2604  s = s.substr(strip.size());
2605  return s;
2606  }
2607 
2608  const std::vector<int64_t>& MayReturn() {
2609  static const int64_t values[] = {
2610  0L,
2611  1L,
2612  2L,
2613  3L
2614  };
2615  static const std::vector<int64_t> retval(values, values + 4);
2616  return retval;
2617  }
2618 
2619 }}
2620 
2621 namespace Rose {
2622  std::string stringifySgAsmFunctionMayReturn(int64_t i, const char *strip, bool canonic) {
2623  std::string retval = stringify::SgAsmFunction::MayReturn(i);
2624  if (retval.empty()) {
2625  retval = "(SgAsmFunction::MayReturn)" + boost::lexical_cast<std::string>(i);
2626  } else {
2627  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2628  retval = retval.substr(strlen(strip));
2629  if (canonic)
2630  retval = "SgAsmFunction::MayReturn::" + retval;
2631  }
2632  return retval;
2633  }
2634 
2635  const std::vector<int64_t>& stringifySgAsmFunctionMayReturn() {
2637  }
2638 }
2639 
2640 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2641 // /src/ROSETTA/src/binaryInstruction.C line 3469
2642 namespace stringify { namespace SgAsmFunction {
2643  const char* FunctionReason(int64_t i) {
2644  switch (i) {
2645  case 0L: return "FUNC_NONE";
2646  case 1L: return "FUNC_INTERPADFUNC";
2647  case 2L: return "FUNC_PESCRAMBLER_DISPATCH";
2648  case 3L: return "FUNC_CONFIGURED";
2649  case 4L: return "FUNC_CMDLINE";
2650  case 5L: return "FUNC_SCAN_RO_DATA";
2651  case 6L: return "FUNC_INSN_RO_DATA";
2652  case 255L: return "FUNC_MISCMASK";
2653  case 16384L: return "FUNC_THUNK_TARGET";
2654  case 32768L: return "FUNC_EXCEPTION_HANDLER";
2655  case 65536L: return "FUNC_ENTRY_POINT";
2656  case 131072L: return "FUNC_CALL_TARGET";
2657  case 262144L: return "FUNC_CALL_INSN";
2658  case 524288L: return "FUNC_EH_FRAME";
2659  case 1048576L: return "FUNC_SYMBOL";
2660  case 2097152L: return "FUNC_PATTERN";
2661  case 4194304L: return "FUNC_GRAPH";
2662  case 8388608L: return "FUNC_USERDEF";
2663  case 16777216L: return "FUNC_PADDING";
2664  case 33554432L: return "FUNC_DISCONT";
2665  case 67108864L: return "FUNC_INSNHEAD";
2666  case 134217728L: return "FUNC_IMPORT";
2667  case 268435456L: return "FUNC_LEFTOVERS";
2668  case 536870912L: return "FUNC_INTRABLOCK";
2669  case 1073741824L: return "FUNC_THUNK";
2670  case 2147483648L: return "FUNC_EXPORT";
2671  case 4026499327L: return "FUNC_DEFAULT";
2672  default: return "";
2673  }
2674  }
2675 
2676  std::string FunctionReason(int64_t i, const std::string &strip) {
2677  std::string s = FunctionReason(i);
2678  if (s.empty())
2679  s = "(SgAsmFunction::FunctionReason)" + boost::lexical_cast<std::string>(i);
2680  if (boost::starts_with(s, strip))
2681  s = s.substr(strip.size());
2682  return s;
2683  }
2684 
2685  const std::vector<int64_t>& FunctionReason() {
2686  static const int64_t values[] = {
2687  0L,
2688  1L,
2689  2L,
2690  3L,
2691  4L,
2692  5L,
2693  6L,
2694  255L,
2695  16384L,
2696  32768L,
2697  65536L,
2698  131072L,
2699  262144L,
2700  524288L,
2701  1048576L,
2702  2097152L,
2703  4194304L,
2704  8388608L,
2705  16777216L,
2706  33554432L,
2707  67108864L,
2708  134217728L,
2709  268435456L,
2710  536870912L,
2711  1073741824L,
2712  2147483648L,
2713  4026499327L
2714  };
2715  static const std::vector<int64_t> retval(values, values + 27);
2716  return retval;
2717  }
2718 
2719 }}
2720 
2721 namespace Rose {
2722  std::string stringifySgAsmFunctionFunctionReason(int64_t i, const char *strip, bool canonic) {
2723  std::string retval = stringify::SgAsmFunction::FunctionReason(i);
2724  if (retval.empty()) {
2725  retval = "(SgAsmFunction::FunctionReason)" + boost::lexical_cast<std::string>(i);
2726  } else {
2727  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2728  retval = retval.substr(strlen(strip));
2729  if (canonic)
2730  retval = "SgAsmFunction::FunctionReason::" + retval;
2731  }
2732  return retval;
2733  }
2734 
2735  const std::vector<int64_t>& stringifySgAsmFunctionFunctionReason() {
2737  }
2738 }
2739 
2740 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2741 // /src/ROSETTA/src/binaryInstruction.C line 3625
2742 namespace stringify { namespace SgAsmFunction {
2743  const char* function_kind_enum(int64_t i) {
2744  switch (i) {
2745  case 0L: return "e_unknown";
2746  case 1L: return "e_standard";
2747  case 2L: return "e_library";
2748  case 3L: return "e_imported";
2749  case 4L: return "e_thunk";
2750  case 5L: return "e_last";
2751  default: return "";
2752  }
2753  }
2754 
2755  std::string function_kind_enum(int64_t i, const std::string &strip) {
2756  std::string s = function_kind_enum(i);
2757  if (s.empty())
2758  s = "(SgAsmFunction::function_kind_enum)" + boost::lexical_cast<std::string>(i);
2759  if (boost::starts_with(s, strip))
2760  s = s.substr(strip.size());
2761  return s;
2762  }
2763 
2764  const std::vector<int64_t>& function_kind_enum() {
2765  static const int64_t values[] = {
2766  0L,
2767  1L,
2768  2L,
2769  3L,
2770  4L,
2771  5L
2772  };
2773  static const std::vector<int64_t> retval(values, values + 6);
2774  return retval;
2775  }
2776 
2777 }}
2778 
2779 namespace Rose {
2780  std::string stringifySgAsmFunction_function_kind_enum(int64_t i, const char *strip, bool canonic) {
2781  std::string retval = stringify::SgAsmFunction::function_kind_enum(i);
2782  if (retval.empty()) {
2783  retval = "(SgAsmFunction::function_kind_enum)" + boost::lexical_cast<std::string>(i);
2784  } else {
2785  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2786  retval = retval.substr(strlen(strip));
2787  if (canonic)
2788  retval = "SgAsmFunction::function_kind_enum::" + retval;
2789  }
2790  return retval;
2791  }
2792 
2793  const std::vector<int64_t>& stringifySgAsmFunction_function_kind_enum() {
2795  }
2796 }
2797 
2798 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2799 // /src/ROSETTA/src/binaryInstruction.C line 3857
2800 namespace stringify { namespace SgAsmBlock {
2801  const char* Reason(int64_t i) {
2802  switch (i) {
2803  case 0L: return "BLK_NONE";
2804  case 1L: return "BLK_FINDDATA";
2805  case 2L: return "BLK_POSTFUNC";
2806  case 255L: return "BLK_MISCMASK";
2807  case 65536L: return "BLK_ENTRY_POINT";
2808  case 131072L: return "BLK_PADDING";
2809  case 524288L: return "BLK_FRAGMENT";
2810  case 1048576L: return "BLK_CFGHEAD";
2811  case 2097152L: return "BLK_USERDEF";
2812  case 4194304L: return "BLK_LEFTOVERS";
2813  case 8388608L: return "BLK_JUMPTABLE";
2814  case 16777216L: return "BLK_GRAPH1";
2815  case 33554432L: return "BLK_GRAPH2";
2816  case 67108864L: return "BLK_GRAPH3";
2817  default: return "";
2818  }
2819  }
2820 
2821  std::string Reason(int64_t i, const std::string &strip) {
2822  std::string s = Reason(i);
2823  if (s.empty())
2824  s = "(SgAsmBlock::Reason)" + boost::lexical_cast<std::string>(i);
2825  if (boost::starts_with(s, strip))
2826  s = s.substr(strip.size());
2827  return s;
2828  }
2829 
2830  const std::vector<int64_t>& Reason() {
2831  static const int64_t values[] = {
2832  0L,
2833  1L,
2834  2L,
2835  255L,
2836  65536L,
2837  131072L,
2838  524288L,
2839  1048576L,
2840  2097152L,
2841  4194304L,
2842  8388608L,
2843  16777216L,
2844  33554432L,
2845  67108864L
2846  };
2847  static const std::vector<int64_t> retval(values, values + 14);
2848  return retval;
2849  }
2850 
2851 }}
2852 
2853 namespace Rose {
2854  std::string stringifySgAsmBlockReason(int64_t i, const char *strip, bool canonic) {
2855  std::string retval = stringify::SgAsmBlock::Reason(i);
2856  if (retval.empty()) {
2857  retval = "(SgAsmBlock::Reason)" + boost::lexical_cast<std::string>(i);
2858  } else {
2859  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2860  retval = retval.substr(strlen(strip));
2861  if (canonic)
2862  retval = "SgAsmBlock::Reason::" + retval;
2863  }
2864  return retval;
2865  }
2866 
2867  const std::vector<int64_t>& stringifySgAsmBlockReason() {
2869  }
2870 }
2871 
2872 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2873 // /src/ROSETTA/src/binaryInstruction.C line 4708
2874 namespace stringify { namespace SgAsmElfFileHeader {
2875  const char* ObjectType(int64_t i) {
2876  switch (i) {
2877  case 0L: return "ET_NONE";
2878  case 1L: return "ET_REL";
2879  case 2L: return "ET_EXEC";
2880  case 3L: return "ET_DYN";
2881  case 4L: return "ET_CORE";
2882  case 65024L: return "ET_LOOS";
2883  case 65279L: return "ET_HIOS";
2884  case 65280L: return "ET_LOPROC";
2885  case 65535L: return "ET_HIPROC";
2886  default: return "";
2887  }
2888  }
2889 
2890  std::string ObjectType(int64_t i, const std::string &strip) {
2891  std::string s = ObjectType(i);
2892  if (s.empty())
2893  s = "(SgAsmElfFileHeader::ObjectType)" + boost::lexical_cast<std::string>(i);
2894  if (boost::starts_with(s, strip))
2895  s = s.substr(strip.size());
2896  return s;
2897  }
2898 
2899  const std::vector<int64_t>& ObjectType() {
2900  static const int64_t values[] = {
2901  0L,
2902  1L,
2903  2L,
2904  3L,
2905  4L,
2906  65024L,
2907  65279L,
2908  65280L,
2909  65535L
2910  };
2911  static const std::vector<int64_t> retval(values, values + 9);
2912  return retval;
2913  }
2914 
2915 }}
2916 
2917 namespace Rose {
2918  std::string stringifySgAsmElfFileHeaderObjectType(int64_t i, const char *strip, bool canonic) {
2919  std::string retval = stringify::SgAsmElfFileHeader::ObjectType(i);
2920  if (retval.empty()) {
2921  retval = "(SgAsmElfFileHeader::ObjectType)" + boost::lexical_cast<std::string>(i);
2922  } else {
2923  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2924  retval = retval.substr(strlen(strip));
2925  if (canonic)
2926  retval = "SgAsmElfFileHeader::ObjectType::" + retval;
2927  }
2928  return retval;
2929  }
2930 
2931  const std::vector<int64_t>& stringifySgAsmElfFileHeaderObjectType() {
2933  }
2934 }
2935 
2936 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2937 // /src/ROSETTA/src/binaryInstruction.C line 5128
2938 namespace stringify { namespace SgAsmElfSectionTableEntry {
2939  const char* SectionType(int64_t i) {
2940  switch (i) {
2941  case 0L: return "SHT_NULL";
2942  case 1L: return "SHT_PROGBITS";
2943  case 2L: return "SHT_SYMTAB";
2944  case 3L: return "SHT_STRTAB";
2945  case 4L: return "SHT_RELA";
2946  case 5L: return "SHT_HASH";
2947  case 6L: return "SHT_DYNAMIC";
2948  case 7L: return "SHT_NOTE";
2949  case 8L: return "SHT_NOBITS";
2950  case 9L: return "SHT_REL";
2951  case 10L: return "SHT_SHLIB";
2952  case 11L: return "SHT_DYNSYM";
2953  case 1610612736L: return "SHT_LOOS";
2954  case 1879048189L: return "SHT_GNU_verdef";
2955  case 1879048190L: return "SHT_GNU_verneed";
2956  case 1879048191L: return "SHT_GNU_versym";
2957  case 1879048192L: return "SHT_LOPROC";
2958  case 2147483647L: return "SHT_HIPROC";
2959  case 2147483648L: return "SHT_LOUSER";
2960  case 4294967295L: return "SHT_HIUSER";
2961  default: return "";
2962  }
2963  }
2964 
2965  std::string SectionType(int64_t i, const std::string &strip) {
2966  std::string s = SectionType(i);
2967  if (s.empty())
2968  s = "(SgAsmElfSectionTableEntry::SectionType)" + boost::lexical_cast<std::string>(i);
2969  if (boost::starts_with(s, strip))
2970  s = s.substr(strip.size());
2971  return s;
2972  }
2973 
2974  const std::vector<int64_t>& SectionType() {
2975  static const int64_t values[] = {
2976  0L,
2977  1L,
2978  2L,
2979  3L,
2980  4L,
2981  5L,
2982  6L,
2983  7L,
2984  8L,
2985  9L,
2986  10L,
2987  11L,
2988  1610612736L,
2989  1879048189L,
2990  1879048190L,
2991  1879048191L,
2992  1879048192L,
2993  2147483647L,
2994  2147483648L,
2995  4294967295L
2996  };
2997  static const std::vector<int64_t> retval(values, values + 20);
2998  return retval;
2999  }
3000 
3001 }}
3002 
3003 namespace Rose {
3004  std::string stringifySgAsmElfSectionTableEntrySectionType(int64_t i, const char *strip, bool canonic) {
3005  std::string retval = stringify::SgAsmElfSectionTableEntry::SectionType(i);
3006  if (retval.empty()) {
3007  retval = "(SgAsmElfSectionTableEntry::SectionType)" + boost::lexical_cast<std::string>(i);
3008  } else {
3009  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3010  retval = retval.substr(strlen(strip));
3011  if (canonic)
3012  retval = "SgAsmElfSectionTableEntry::SectionType::" + retval;
3013  }
3014  return retval;
3015  }
3016 
3017  const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionType() {
3019  }
3020 }
3021 
3022 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3023 // /src/ROSETTA/src/binaryInstruction.C line 5155
3024 namespace stringify { namespace SgAsmElfSectionTableEntry {
3025  const char* SectionFlags(int64_t i) {
3026  switch (i) {
3027  case 0L: return "SHF_NULL";
3028  case 1L: return "SHF_WRITE";
3029  case 2L: return "SHF_ALLOC";
3030  case 4L: return "SHF_EXECINSTR";
3031  case 16L: return "SHF_MERGE";
3032  case 32L: return "SHF_STRINGS";
3033  case 64L: return "SHF_INFO_LINK";
3034  case 128L: return "SHF_LINK_ORDER";
3035  case 256L: return "SHF_OS_NONCONFORMING";
3036  case 512L: return "SHF_GROUP";
3037  case 1024L: return "SHF_TLS";
3038  case 267386880L: return "SHF_MASKOS";
3039  case 4026531840L: return "SHF_MASKPROC";
3040  default: return "";
3041  }
3042  }
3043 
3044  std::string SectionFlags(int64_t i, const std::string &strip) {
3045  std::string s = SectionFlags(i);
3046  if (s.empty())
3047  s = "(SgAsmElfSectionTableEntry::SectionFlags)" + boost::lexical_cast<std::string>(i);
3048  if (boost::starts_with(s, strip))
3049  s = s.substr(strip.size());
3050  return s;
3051  }
3052 
3053  const std::vector<int64_t>& SectionFlags() {
3054  static const int64_t values[] = {
3055  0L,
3056  1L,
3057  2L,
3058  4L,
3059  16L,
3060  32L,
3061  64L,
3062  128L,
3063  256L,
3064  512L,
3065  1024L,
3066  267386880L,
3067  4026531840L
3068  };
3069  static const std::vector<int64_t> retval(values, values + 13);
3070  return retval;
3071  }
3072 
3073 }}
3074 
3075 namespace Rose {
3076  std::string stringifySgAsmElfSectionTableEntrySectionFlags(int64_t i, const char *strip, bool canonic) {
3078  if (retval.empty()) {
3079  retval = "(SgAsmElfSectionTableEntry::SectionFlags)" + boost::lexical_cast<std::string>(i);
3080  } else {
3081  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3082  retval = retval.substr(strlen(strip));
3083  if (canonic)
3084  retval = "SgAsmElfSectionTableEntry::SectionFlags::" + retval;
3085  }
3086  return retval;
3087  }
3088 
3089  const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionFlags() {
3091  }
3092 }
3093 
3094 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3095 // /src/ROSETTA/src/binaryInstruction.C line 5557
3096 namespace stringify { namespace SgAsmElfSegmentTableEntry {
3097  const char* SegmentType(int64_t i) {
3098  switch (i) {
3099  case 0L: return "PT_NULL";
3100  case 1L: return "PT_LOAD";
3101  case 2L: return "PT_DYNAMIC";
3102  case 3L: return "PT_INTERP";
3103  case 4L: return "PT_NOTE";
3104  case 5L: return "PT_SHLIB";
3105  case 6L: return "PT_PHDR";
3106  case 7L: return "PT_TLS";
3107  case 1610612736L: return "PT_LOOS";
3108  case 1685382480L: return "PT_GNU_EH_FRAME";
3109  case 1685382481L: return "PT_GNU_STACK";
3110  case 1685382482L: return "PT_GNU_RELRO";
3111  case 1694766464L: return "PT_PAX_FLAGS";
3112  case 1879048186L: return "PT_SUNWBSS";
3113  case 1879048187L: return "PT_SUNWSTACK";
3114  case 1879048191L: return "PT_HIOS";
3115  case 1879048192L: return "PT_LOPROC";
3116  case 2147483647L: return "PT_HIPROC";
3117  default: return "";
3118  }
3119  }
3120 
3121  std::string SegmentType(int64_t i, const std::string &strip) {
3122  std::string s = SegmentType(i);
3123  if (s.empty())
3124  s = "(SgAsmElfSegmentTableEntry::SegmentType)" + boost::lexical_cast<std::string>(i);
3125  if (boost::starts_with(s, strip))
3126  s = s.substr(strip.size());
3127  return s;
3128  }
3129 
3130  const std::vector<int64_t>& SegmentType() {
3131  static const int64_t values[] = {
3132  0L,
3133  1L,
3134  2L,
3135  3L,
3136  4L,
3137  5L,
3138  6L,
3139  7L,
3140  1610612736L,
3141  1685382480L,
3142  1685382481L,
3143  1685382482L,
3144  1694766464L,
3145  1879048186L,
3146  1879048187L,
3147  1879048191L,
3148  1879048192L,
3149  2147483647L
3150  };
3151  static const std::vector<int64_t> retval(values, values + 18);
3152  return retval;
3153  }
3154 
3155 }}
3156 
3157 namespace Rose {
3158  std::string stringifySgAsmElfSegmentTableEntrySegmentType(int64_t i, const char *strip, bool canonic) {
3159  std::string retval = stringify::SgAsmElfSegmentTableEntry::SegmentType(i);
3160  if (retval.empty()) {
3161  retval = "(SgAsmElfSegmentTableEntry::SegmentType)" + boost::lexical_cast<std::string>(i);
3162  } else {
3163  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3164  retval = retval.substr(strlen(strip));
3165  if (canonic)
3166  retval = "SgAsmElfSegmentTableEntry::SegmentType::" + retval;
3167  }
3168  return retval;
3169  }
3170 
3171  const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentType() {
3173  }
3174 }
3175 
3176 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3177 // /src/ROSETTA/src/binaryInstruction.C line 5585
3178 namespace stringify { namespace SgAsmElfSegmentTableEntry {
3179  const char* SegmentFlags(int64_t i) {
3180  switch (i) {
3181  case 0L: return "PF_NONE";
3182  case 1L: return "PF_XPERM";
3183  case 2L: return "PF_WPERM";
3184  case 4L: return "PF_RPERM";
3185  case 1048568L: return "PF_RESERVED";
3186  case 267386880L: return "PF_OS_MASK";
3187  case 4026531840L: return "PF_PROC_MASK";
3188  default: return "";
3189  }
3190  }
3191 
3192  std::string SegmentFlags(int64_t i, const std::string &strip) {
3193  std::string s = SegmentFlags(i);
3194  if (s.empty())
3195  s = "(SgAsmElfSegmentTableEntry::SegmentFlags)" + boost::lexical_cast<std::string>(i);
3196  if (boost::starts_with(s, strip))
3197  s = s.substr(strip.size());
3198  return s;
3199  }
3200 
3201  const std::vector<int64_t>& SegmentFlags() {
3202  static const int64_t values[] = {
3203  0L,
3204  1L,
3205  2L,
3206  4L,
3207  1048568L,
3208  267386880L,
3209  4026531840L
3210  };
3211  static const std::vector<int64_t> retval(values, values + 7);
3212  return retval;
3213  }
3214 
3215 }}
3216 
3217 namespace Rose {
3218  std::string stringifySgAsmElfSegmentTableEntrySegmentFlags(int64_t i, const char *strip, bool canonic) {
3220  if (retval.empty()) {
3221  retval = "(SgAsmElfSegmentTableEntry::SegmentFlags)" + boost::lexical_cast<std::string>(i);
3222  } else {
3223  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3224  retval = retval.substr(strlen(strip));
3225  if (canonic)
3226  retval = "SgAsmElfSegmentTableEntry::SegmentFlags::" + retval;
3227  }
3228  return retval;
3229  }
3230 
3231  const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentFlags() {
3233  }
3234 }
3235 
3236 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3237 // /src/ROSETTA/src/binaryInstruction.C line 5931
3238 namespace stringify { namespace SgAsmElfSymbol {
3239  const char* ElfSymBinding(int64_t i) {
3240  switch (i) {
3241  case 0L: return "STB_LOCAL";
3242  case 1L: return "STB_GLOBAL";
3243  case 2L: return "STB_WEAK";
3244  default: return "";
3245  }
3246  }
3247 
3248  std::string ElfSymBinding(int64_t i, const std::string &strip) {
3249  std::string s = ElfSymBinding(i);
3250  if (s.empty())
3251  s = "(SgAsmElfSymbol::ElfSymBinding)" + boost::lexical_cast<std::string>(i);
3252  if (boost::starts_with(s, strip))
3253  s = s.substr(strip.size());
3254  return s;
3255  }
3256 
3257  const std::vector<int64_t>& ElfSymBinding() {
3258  static const int64_t values[] = {
3259  0L,
3260  1L,
3261  2L
3262  };
3263  static const std::vector<int64_t> retval(values, values + 3);
3264  return retval;
3265  }
3266 
3267 }}
3268 
3269 namespace Rose {
3270  std::string stringifySgAsmElfSymbolElfSymBinding(int64_t i, const char *strip, bool canonic) {
3271  std::string retval = stringify::SgAsmElfSymbol::ElfSymBinding(i);
3272  if (retval.empty()) {
3273  retval = "(SgAsmElfSymbol::ElfSymBinding)" + boost::lexical_cast<std::string>(i);
3274  } else {
3275  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3276  retval = retval.substr(strlen(strip));
3277  if (canonic)
3278  retval = "SgAsmElfSymbol::ElfSymBinding::" + retval;
3279  }
3280  return retval;
3281  }
3282 
3283  const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymBinding() {
3285  }
3286 }
3287 
3288 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3289 // /src/ROSETTA/src/binaryInstruction.C line 5937
3290 namespace stringify { namespace SgAsmElfSymbol {
3291  const char* ElfSymType(int64_t i) {
3292  switch (i) {
3293  case 0L: return "STT_NOTYPE";
3294  case 1L: return "STT_OBJECT";
3295  case 2L: return "STT_FUNC";
3296  case 3L: return "STT_SECTION";
3297  case 4L: return "STT_FILE";
3298  case 5L: return "STT_COMMON";
3299  case 6L: return "STT_TLS";
3300  case 10L: return "STT_IFUNC";
3301  default: return "";
3302  }
3303  }
3304 
3305  std::string ElfSymType(int64_t i, const std::string &strip) {
3306  std::string s = ElfSymType(i);
3307  if (s.empty())
3308  s = "(SgAsmElfSymbol::ElfSymType)" + boost::lexical_cast<std::string>(i);
3309  if (boost::starts_with(s, strip))
3310  s = s.substr(strip.size());
3311  return s;
3312  }
3313 
3314  const std::vector<int64_t>& ElfSymType() {
3315  static const int64_t values[] = {
3316  0L,
3317  1L,
3318  2L,
3319  3L,
3320  4L,
3321  5L,
3322  6L,
3323  10L
3324  };
3325  static const std::vector<int64_t> retval(values, values + 8);
3326  return retval;
3327  }
3328 
3329 }}
3330 
3331 namespace Rose {
3332  std::string stringifySgAsmElfSymbolElfSymType(int64_t i, const char *strip, bool canonic) {
3333  std::string retval = stringify::SgAsmElfSymbol::ElfSymType(i);
3334  if (retval.empty()) {
3335  retval = "(SgAsmElfSymbol::ElfSymType)" + boost::lexical_cast<std::string>(i);
3336  } else {
3337  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3338  retval = retval.substr(strlen(strip));
3339  if (canonic)
3340  retval = "SgAsmElfSymbol::ElfSymType::" + retval;
3341  }
3342  return retval;
3343  }
3344 
3345  const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymType() {
3347  }
3348 }
3349 
3350 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3351 // /src/ROSETTA/src/binaryInstruction.C line 7339
3352 namespace stringify { namespace SgAsmElfRelocEntry {
3353  const char* RelocType(int64_t i) {
3354  switch (i) {
3355  case 0L: return "R_386_NONE";
3356  case 1L: return "R_386_32";
3357  case 2L: return "R_386_PC32";
3358  case 3L: return "R_386_GOT32";
3359  case 4L: return "R_386_PLT32";
3360  case 5L: return "R_386_COPY";
3361  case 6L: return "R_386_GLOB_DAT";
3362  case 7L: return "R_386_JMP_SLOT";
3363  case 8L: return "R_386_RELATIVE";
3364  case 9L: return "R_386_GOTOFF";
3365  case 10L: return "R_386_GOTPC";
3366  case 11L: return "R_386_32PLT";
3367  case 14L: return "R_386_TLS_TPOFF";
3368  case 15L: return "R_386_TLS_IE";
3369  case 16L: return "R_386_TLS_GOTIE";
3370  case 17L: return "R_386_TLS_LE";
3371  case 18L: return "R_386_TLS_GD";
3372  case 19L: return "R_386_TLS_LDM";
3373  case 20L: return "R_386_16";
3374  case 21L: return "R_386_PC16";
3375  case 22L: return "R_386_8";
3376  case 23L: return "R_386_PC8";
3377  case 24L: return "R_386_TLS_GD_32";
3378  case 25L: return "R_386_TLS_GD_PUSH";
3379  case 26L: return "R_386_TLS_GD_CALL";
3380  case 27L: return "R_386_TLS_GD_POP";
3381  case 28L: return "R_386_TLS_LDM_32";
3382  case 29L: return "R_386_TLS_LDM_PUSH";
3383  case 30L: return "R_386_TLS_LDM_CALL";
3384  case 31L: return "R_386_TLS_LDM_POP";
3385  case 32L: return "R_386_TLS_LDO_32";
3386  case 33L: return "R_386_TLS_IE_32";
3387  case 34L: return "R_386_TLS_LE_32";
3388  case 35L: return "R_386_TLS_DTPMOD32";
3389  case 36L: return "R_386_TLS_DTPOFF32";
3390  case 37L: return "R_386_TLS_TPOFF32";
3391  case 100L: return "R_X86_64_NONE";
3392  case 101L: return "R_X86_64_64";
3393  case 102L: return "R_X86_64_PC32";
3394  case 103L: return "R_X86_64_GOT32";
3395  case 104L: return "R_X86_64_PLT32";
3396  case 105L: return "R_X86_64_COPY";
3397  case 106L: return "R_X86_64_GLOB_DAT";
3398  case 107L: return "R_X86_64_JUMP_SLOT";
3399  case 108L: return "R_X86_64_RELATIVE";
3400  case 109L: return "R_X86_64_GOTPCREL";
3401  case 110L: return "R_X86_64_32";
3402  case 111L: return "R_X86_64_32S";
3403  case 112L: return "R_X86_64_16";
3404  case 113L: return "R_X86_64_PC16";
3405  case 114L: return "R_X86_64_8";
3406  case 115L: return "R_X86_64_PC8";
3407  case 116L: return "R_X86_64_DTPMOD64";
3408  case 117L: return "R_X86_64_DTPOFF64";
3409  case 118L: return "R_X86_64_TPOFF64";
3410  case 119L: return "R_X86_64_TLSGD";
3411  case 120L: return "R_X86_64_TLSLD";
3412  case 121L: return "R_X86_64_DTPOFF32";
3413  case 122L: return "R_X86_64_GOTTPOFF";
3414  case 123L: return "R_X86_64_TPOFF32";
3415  default: return "";
3416  }
3417  }
3418 
3419  std::string RelocType(int64_t i, const std::string &strip) {
3420  std::string s = RelocType(i);
3421  if (s.empty())
3422  s = "(SgAsmElfRelocEntry::RelocType)" + boost::lexical_cast<std::string>(i);
3423  if (boost::starts_with(s, strip))
3424  s = s.substr(strip.size());
3425  return s;
3426  }
3427 
3428  const std::vector<int64_t>& RelocType() {
3429  static const int64_t values[] = {
3430  0L,
3431  1L,
3432  2L,
3433  3L,
3434  4L,
3435  5L,
3436  6L,
3437  7L,
3438  8L,
3439  9L,
3440  10L,
3441  11L,
3442  14L,
3443  15L,
3444  16L,
3445  17L,
3446  18L,
3447  19L,
3448  20L,
3449  21L,
3450  22L,
3451  23L,
3452  24L,
3453  25L,
3454  26L,
3455  27L,
3456  28L,
3457  29L,
3458  30L,
3459  31L,
3460  32L,
3461  33L,
3462  34L,
3463  35L,
3464  36L,
3465  37L,
3466  100L,
3467  101L,
3468  102L,
3469  103L,
3470  104L,
3471  105L,
3472  106L,
3473  107L,
3474  108L,
3475  109L,
3476  110L,
3477  111L,
3478  112L,
3479  113L,
3480  114L,
3481  115L,
3482  116L,
3483  117L,
3484  118L,
3485  119L,
3486  120L,
3487  121L,
3488  122L,
3489  123L
3490  };
3491  static const std::vector<int64_t> retval(values, values + 60);
3492  return retval;
3493  }
3494 
3495 }}
3496 
3497 namespace Rose {
3498  std::string stringifySgAsmElfRelocEntryRelocType(int64_t i, const char *strip, bool canonic) {
3499  std::string retval = stringify::SgAsmElfRelocEntry::RelocType(i);
3500  if (retval.empty()) {
3501  retval = "(SgAsmElfRelocEntry::RelocType)" + boost::lexical_cast<std::string>(i);
3502  } else {
3503  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3504  retval = retval.substr(strlen(strip));
3505  if (canonic)
3506  retval = "SgAsmElfRelocEntry::RelocType::" + retval;
3507  }
3508  return retval;
3509  }
3510 
3511  const std::vector<int64_t>& stringifySgAsmElfRelocEntryRelocType() {
3513  }
3514 }
3515 
3516 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3517 // /src/ROSETTA/src/binaryInstruction.C line 7696
3518 namespace stringify { namespace SgAsmElfDynamicEntry {
3519  const char* EntryType(int64_t i) {
3520  switch (i) {
3521  case 0L: return "DT_NULL";
3522  case 1L: return "DT_NEEDED";
3523  case 2L: return "DT_PLTRELSZ";
3524  case 3L: return "DT_PLTGOT";
3525  case 4L: return "DT_HASH";
3526  case 5L: return "DT_STRTAB";
3527  case 6L: return "DT_SYMTAB";
3528  case 7L: return "DT_RELA";
3529  case 8L: return "DT_RELASZ";
3530  case 9L: return "DT_RELAENT";
3531  case 10L: return "DT_STRSZ";
3532  case 11L: return "DT_SYMENT";
3533  case 12L: return "DT_INIT";
3534  case 13L: return "DT_FINI";
3535  case 14L: return "DT_SONAME";
3536  case 15L: return "DT_RPATH";
3537  case 16L: return "DT_SYMBOLIC";
3538  case 17L: return "DT_REL";
3539  case 18L: return "DT_RELSZ";
3540  case 19L: return "DT_RELENT";
3541  case 20L: return "DT_PLTREL";
3542  case 21L: return "DT_DEBUG";
3543  case 22L: return "DT_TEXTREL";
3544  case 23L: return "DT_JMPREL";
3545  case 24L: return "DT_BIND_NOW";
3546  case 25L: return "DT_INIT_ARRAY";
3547  case 26L: return "DT_FINI_ARRAY";
3548  case 27L: return "DT_INIT_ARRAYSZ";
3549  case 28L: return "DT_FINI_ARRAYSZ";
3550  case 29L: return "DT_RUNPATH";
3551  case 30L: return "DT_FLAGS";
3552  case 32L: return "DT_PREINIT_ARRAY";
3553  case 33L: return "DT_PREINIT_ARRAYSZ";
3554  case 34L: return "DT_NUM";
3555  case 1879047669L: return "DT_GNU_PRELINKED";
3556  case 1879047670L: return "DT_GNU_CONFLICTSZ";
3557  case 1879047671L: return "DT_GNU_LIBLISTSZ";
3558  case 1879047672L: return "DT_CHECKSUM";
3559  case 1879047673L: return "DT_PLTPADSZ";
3560  case 1879047674L: return "DT_MOVEENT";
3561  case 1879047675L: return "DT_MOVESZ";
3562  case 1879047676L: return "DT_FEATURE_1";
3563  case 1879047677L: return "DT_POSFLAG_1";
3564  case 1879047678L: return "DT_SYMINSZ";
3565  case 1879047679L: return "DT_SYMINENT";
3566  case 1879047925L: return "DT_GNU_HASH";
3567  case 1879047926L: return "DT_TLSDESC_PLT";
3568  case 1879047927L: return "DT_TLSDESC_GOT";
3569  case 1879047928L: return "DT_GNU_CONFLICT";
3570  case 1879047929L: return "DT_GNU_LIBLIST";
3571  case 1879047930L: return "DT_CONFIG";
3572  case 1879047931L: return "DT_DEPAUDIT";
3573  case 1879047932L: return "DT_AUDIT";
3574  case 1879047933L: return "DT_PLTPAD";
3575  case 1879047934L: return "DT_MOVETAB";
3576  case 1879047935L: return "DT_SYMINFO";
3577  case 1879048176L: return "DT_VERSYM";
3578  case 1879048185L: return "DT_RELACOUNT";
3579  case 1879048186L: return "DT_RELCOUNT";
3580  case 1879048187L: return "DT_FLAGS_1";
3581  case 1879048188L: return "DT_VERDEF";
3582  case 1879048189L: return "DT_VERDEFNUM";
3583  case 1879048190L: return "DT_VERNEED";
3584  case 1879048191L: return "DT_VERNEEDNUM";
3585  case 2147483645L: return "DT_AUXILIARY";
3586  case 2147483647L: return "DT_FILTER";
3587  default: return "";
3588  }
3589  }
3590 
3591  std::string EntryType(int64_t i, const std::string &strip) {
3592  std::string s = EntryType(i);
3593  if (s.empty())
3594  s = "(SgAsmElfDynamicEntry::EntryType)" + boost::lexical_cast<std::string>(i);
3595  if (boost::starts_with(s, strip))
3596  s = s.substr(strip.size());
3597  return s;
3598  }
3599 
3600  const std::vector<int64_t>& EntryType() {
3601  static const int64_t values[] = {
3602  0L,
3603  1L,
3604  2L,
3605  3L,
3606  4L,
3607  5L,
3608  6L,
3609  7L,
3610  8L,
3611  9L,
3612  10L,
3613  11L,
3614  12L,
3615  13L,
3616  14L,
3617  15L,
3618  16L,
3619  17L,
3620  18L,
3621  19L,
3622  20L,
3623  21L,
3624  22L,
3625  23L,
3626  24L,
3627  25L,
3628  26L,
3629  27L,
3630  28L,
3631  29L,
3632  30L,
3633  32L,
3634  33L,
3635  34L,
3636  1879047669L,
3637  1879047670L,
3638  1879047671L,
3639  1879047672L,
3640  1879047673L,
3641  1879047674L,
3642  1879047675L,
3643  1879047676L,
3644  1879047677L,
3645  1879047678L,
3646  1879047679L,
3647  1879047925L,
3648  1879047926L,
3649  1879047927L,
3650  1879047928L,
3651  1879047929L,
3652  1879047930L,
3653  1879047931L,
3654  1879047932L,
3655  1879047933L,
3656  1879047934L,
3657  1879047935L,
3658  1879048176L,
3659  1879048185L,
3660  1879048186L,
3661  1879048187L,
3662  1879048188L,
3663  1879048189L,
3664  1879048190L,
3665  1879048191L,
3666  2147483645L,
3667  2147483647L
3668  };
3669  static const std::vector<int64_t> retval(values, values + 66);
3670  return retval;
3671  }
3672 
3673 }}
3674 
3675 namespace Rose {
3676  std::string stringifySgAsmElfDynamicEntryEntryType(int64_t i, const char *strip, bool canonic) {
3677  std::string retval = stringify::SgAsmElfDynamicEntry::EntryType(i);
3678  if (retval.empty()) {
3679  retval = "(SgAsmElfDynamicEntry::EntryType)" + boost::lexical_cast<std::string>(i);
3680  } else {
3681  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3682  retval = retval.substr(strlen(strip));
3683  if (canonic)
3684  retval = "SgAsmElfDynamicEntry::EntryType::" + retval;
3685  }
3686  return retval;
3687  }
3688 
3689  const std::vector<int64_t>& stringifySgAsmElfDynamicEntryEntryType() {
3691  }
3692 }
3693 
3694 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3695 // /src/ROSETTA/src/binaryInstruction.C line 10195
3696 namespace stringify { namespace SgAsmPEFileHeader {
3697  const char* HeaderFlags(int64_t i) {
3698  switch (i) {
3699  case 0L: return "HF_PROGRAM";
3700  case 2L: return "HF_EXECUTABLE";
3701  case 512L: return "HF_FIXED";
3702  case 8192L: return "HF_LIBRARY";
3703  case 56829L: return "HF_RESERVED_MASK";
3704  default: return "";
3705  }
3706  }
3707 
3708  std::string HeaderFlags(int64_t i, const std::string &strip) {
3709  std::string s = HeaderFlags(i);
3710  if (s.empty())
3711  s = "(SgAsmPEFileHeader::HeaderFlags)" + boost::lexical_cast<std::string>(i);
3712  if (boost::starts_with(s, strip))
3713  s = s.substr(strip.size());
3714  return s;
3715  }
3716 
3717  const std::vector<int64_t>& HeaderFlags() {
3718  static const int64_t values[] = {
3719  0L,
3720  2L,
3721  512L,
3722  8192L,
3723  56829L
3724  };
3725  static const std::vector<int64_t> retval(values, values + 5);
3726  return retval;
3727  }
3728 
3729 }}
3730 
3731 namespace Rose {
3732  std::string stringifySgAsmPEFileHeaderHeaderFlags(int64_t i, const char *strip, bool canonic) {
3733  std::string retval = stringify::SgAsmPEFileHeader::HeaderFlags(i);
3734  if (retval.empty()) {
3735  retval = "(SgAsmPEFileHeader::HeaderFlags)" + boost::lexical_cast<std::string>(i);
3736  } else {
3737  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3738  retval = retval.substr(strlen(strip));
3739  if (canonic)
3740  retval = "SgAsmPEFileHeader::HeaderFlags::" + retval;
3741  }
3742  return retval;
3743  }
3744 
3745  const std::vector<int64_t>& stringifySgAsmPEFileHeaderHeaderFlags() {
3747  }
3748 }
3749 
3750 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3751 // /src/ROSETTA/src/binaryInstruction.C line 10204
3752 namespace stringify { namespace SgAsmPEFileHeader {
3753  const char* Subsystem(int64_t i) {
3754  switch (i) {
3755  case 0L: return "HF_SPEC_UNKNOWN";
3756  case 1L: return "HF_NATIVE";
3757  case 2L: return "HF_WINGUI";
3758  case 3L: return "HF_WINCHAR";
3759  case 5L: return "HF_OS2CHAR";
3760  case 7L: return "HF_POSIX";
3761  default: return "";
3762  }
3763  }
3764 
3765  std::string Subsystem(int64_t i, const std::string &strip) {
3766  std::string s = Subsystem(i);
3767  if (s.empty())
3768  s = "(SgAsmPEFileHeader::Subsystem)" + boost::lexical_cast<std::string>(i);
3769  if (boost::starts_with(s, strip))
3770  s = s.substr(strip.size());
3771  return s;
3772  }
3773 
3774  const std::vector<int64_t>& Subsystem() {
3775  static const int64_t values[] = {
3776  0L,
3777  1L,
3778  2L,
3779  3L,
3780  5L,
3781  7L
3782  };
3783  static const std::vector<int64_t> retval(values, values + 6);
3784  return retval;
3785  }
3786 
3787 }}
3788 
3789 namespace Rose {
3790  std::string stringifySgAsmPEFileHeaderSubsystem(int64_t i, const char *strip, bool canonic) {
3791  std::string retval = stringify::SgAsmPEFileHeader::Subsystem(i);
3792  if (retval.empty()) {
3793  retval = "(SgAsmPEFileHeader::Subsystem)" + boost::lexical_cast<std::string>(i);
3794  } else {
3795  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3796  retval = retval.substr(strlen(strip));
3797  if (canonic)
3798  retval = "SgAsmPEFileHeader::Subsystem::" + retval;
3799  }
3800  return retval;
3801  }
3802 
3803  const std::vector<int64_t>& stringifySgAsmPEFileHeaderSubsystem() {
3805  }
3806 }
3807 
3808 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3809 // /src/ROSETTA/src/binaryInstruction.C line 10214
3810 namespace stringify { namespace SgAsmPEFileHeader {
3811  const char* DLLFlags(int64_t i) {
3812  switch (i) {
3813  case 1L: return "DLL_PROC_INIT";
3814  case 2L: return "DLL_PROC_TERM";
3815  case 4L: return "DLL_THRD_INIT";
3816  case 8L: return "DLL_THRD_TERM";
3817  case 65520L: return "DLL_RESERVED_MASK";
3818  default: return "";
3819  }
3820  }
3821 
3822  std::string DLLFlags(int64_t i, const std::string &strip) {
3823  std::string s = DLLFlags(i);
3824  if (s.empty())
3825  s = "(SgAsmPEFileHeader::DLLFlags)" + boost::lexical_cast<std::string>(i);
3826  if (boost::starts_with(s, strip))
3827  s = s.substr(strip.size());
3828  return s;
3829  }
3830 
3831  const std::vector<int64_t>& DLLFlags() {
3832  static const int64_t values[] = {
3833  1L,
3834  2L,
3835  4L,
3836  8L,
3837  65520L
3838  };
3839  static const std::vector<int64_t> retval(values, values + 5);
3840  return retval;
3841  }
3842 
3843 }}
3844 
3845 namespace Rose {
3846  std::string stringifySgAsmPEFileHeaderDLLFlags(int64_t i, const char *strip, bool canonic) {
3847  std::string retval = stringify::SgAsmPEFileHeader::DLLFlags(i);
3848  if (retval.empty()) {
3849  retval = "(SgAsmPEFileHeader::DLLFlags)" + boost::lexical_cast<std::string>(i);
3850  } else {
3851  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3852  retval = retval.substr(strlen(strip));
3853  if (canonic)
3854  retval = "SgAsmPEFileHeader::DLLFlags::" + retval;
3855  }
3856  return retval;
3857  }
3858 
3859  const std::vector<int64_t>& stringifySgAsmPEFileHeaderDLLFlags() {
3861  }
3862 }
3863 
3864 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3865 // /src/ROSETTA/src/binaryInstruction.C line 10223
3866 namespace stringify { namespace SgAsmPEFileHeader {
3867  const char* PairPurpose(int64_t i) {
3868  switch (i) {
3869  case 0L: return "PAIR_EXPORTS";
3870  case 1L: return "PAIR_IMPORTS";
3871  case 2L: return "PAIR_RESOURCES";
3872  case 3L: return "PAIR_EXCEPTIONS";
3873  case 4L: return "PAIR_CERTIFICATES";
3874  case 5L: return "PAIR_BASERELOCS";
3875  case 6L: return "PAIR_DEBUG";
3876  case 7L: return "PAIR_ARCHITECTURE";
3877  case 8L: return "PAIR_GLOBALPTR";
3878  case 9L: return "PAIR_TLS";
3879  case 10L: return "PAIR_LOADCONFIG";
3880  case 11L: return "PAIR_BOUNDIMPORT";
3881  case 12L: return "PAIR_IAT";
3882  case 13L: return "PAIR_DELAYIMPORT";
3883  case 14L: return "PAIR_CLRRUNTIME";
3884  case 15L: return "PAIR_RESERVED15";
3885  default: return "";
3886  }
3887  }
3888 
3889  std::string PairPurpose(int64_t i, const std::string &strip) {
3890  std::string s = PairPurpose(i);
3891  if (s.empty())
3892  s = "(SgAsmPEFileHeader::PairPurpose)" + boost::lexical_cast<std::string>(i);
3893  if (boost::starts_with(s, strip))
3894  s = s.substr(strip.size());
3895  return s;
3896  }
3897 
3898  const std::vector<int64_t>& PairPurpose() {
3899  static const int64_t values[] = {
3900  0L,
3901  1L,
3902  2L,
3903  3L,
3904  4L,
3905  5L,
3906  6L,
3907  7L,
3908  8L,
3909  9L,
3910  10L,
3911  11L,
3912  12L,
3913  13L,
3914  14L,
3915  15L
3916  };
3917  static const std::vector<int64_t> retval(values, values + 16);
3918  return retval;
3919  }
3920 
3921 }}
3922 
3923 namespace Rose {
3924  std::string stringifySgAsmPEFileHeaderPairPurpose(int64_t i, const char *strip, bool canonic) {
3925  std::string retval = stringify::SgAsmPEFileHeader::PairPurpose(i);
3926  if (retval.empty()) {
3927  retval = "(SgAsmPEFileHeader::PairPurpose)" + 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 = "SgAsmPEFileHeader::PairPurpose::" + retval;
3933  }
3934  return retval;
3935  }
3936 
3937  const std::vector<int64_t>& stringifySgAsmPEFileHeaderPairPurpose() {
3939  }
3940 }
3941 
3942 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3943 // /src/ROSETTA/src/binaryInstruction.C line 12004
3944 namespace stringify { namespace SgAsmPESectionTableEntry {
3945  const char* PESectionFlags(int64_t i) {
3946  switch (i) {
3947  case 32L: return "OF_CODE";
3948  case 64L: return "OF_IDATA";
3949  case 128L: return "OF_UDATA";
3950  case 512L: return "OF_INFO";
3951  case 2048L: return "OF_REMOVE";
3952  case 4096L: return "OF_COMDAT";
3953  case 16384L: return "OF_NO_DEFER_SPEC_EXC";
3954  case 32768L: return "OF_GPREL";
3955  case 1048576L: return "OF_ALIGN_1";
3956  case 2097152L: return "OF_ALIGN_2";
3957  case 3145728L: return "OF_ALIGN_4";
3958  case 4194304L: return "OF_ALIGN_8";
3959  case 5242880L: return "OF_ALIGN_16";
3960  case 6291456L: return "OF_ALIGN_32";
3961  case 7340032L: return "OF_ALIGN_64";
3962  case 8388608L: return "OF_ALIGN_128";
3963  case 9437184L: return "OF_ALIGN_256";
3964  case 10485760L: return "OF_ALIGN_512";
3965  case 11534336L: return "OF_ALIGN_1k";
3966  case 12582912L: return "OF_ALIGN_2k";
3967  case 13631488L: return "OF_ALIGN_4k";
3968  case 14680064L: return "OF_ALIGN_8k";
3969  case 15728640L: return "OF_ALIGN_MASK";
3970  case 16777216L: return "OF_NRELOC_OVFL";
3971  case 33554432L: return "OF_DISCARDABLE";
3972  case 67108864L: return "OF_NO_CACHE";
3973  case 134217728L: return "OF_NO_PAGING";
3974  case 268435456L: return "OF_SHARED";
3975  case 536870912L: return "OF_EXECUTABLE";
3976  case 1073741824L: return "OF_READABLE";
3977  case 2147483648L: return "OF_WRITABLE";
3978  default: return "";
3979  }
3980  }
3981 
3982  std::string PESectionFlags(int64_t i, const std::string &strip) {
3983  std::string s = PESectionFlags(i);
3984  if (s.empty())
3985  s = "(SgAsmPESectionTableEntry::PESectionFlags)" + boost::lexical_cast<std::string>(i);
3986  if (boost::starts_with(s, strip))
3987  s = s.substr(strip.size());
3988  return s;
3989  }
3990 
3991  const std::vector<int64_t>& PESectionFlags() {
3992  static const int64_t values[] = {
3993  32L,
3994  64L,
3995  128L,
3996  512L,
3997  2048L,
3998  4096L,
3999  16384L,
4000  32768L,
4001  1048576L,
4002  2097152L,
4003  3145728L,
4004  4194304L,
4005  5242880L,
4006  6291456L,
4007  7340032L,
4008  8388608L,
4009  9437184L,
4010  10485760L,
4011  11534336L,
4012  12582912L,
4013  13631488L,
4014  14680064L,
4015  15728640L,
4016  16777216L,
4017  33554432L,
4018  67108864L,
4019  134217728L,
4020  268435456L,
4021  536870912L,
4022  1073741824L,
4023  2147483648L
4024  };
4025  static const std::vector<int64_t> retval(values, values + 31);
4026  return retval;
4027  }
4028 
4029 }}
4030 
4031 namespace Rose {
4032  std::string stringifySgAsmPESectionTableEntryPESectionFlags(int64_t i, const char *strip, bool canonic) {
4034  if (retval.empty()) {
4035  retval = "(SgAsmPESectionTableEntry::PESectionFlags)" + boost::lexical_cast<std::string>(i);
4036  } else {
4037  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4038  retval = retval.substr(strlen(strip));
4039  if (canonic)
4040  retval = "SgAsmPESectionTableEntry::PESectionFlags::" + retval;
4041  }
4042  return retval;
4043  }
4044 
4045  const std::vector<int64_t>& stringifySgAsmPESectionTableEntryPESectionFlags() {
4047  }
4048 }
4049 
4050 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4051 // /src/ROSETTA/src/binaryInstruction.C line 14032
4052 namespace stringify { namespace SgAsmGenericSymbol {
4053  const char* SymbolDefState(int64_t i) {
4054  switch (i) {
4055  case 0L: return "SYM_UNDEFINED";
4056  case 1L: return "SYM_TENTATIVE";
4057  case 2L: return "SYM_DEFINED";
4058  default: return "";
4059  }
4060  }
4061 
4062  std::string SymbolDefState(int64_t i, const std::string &strip) {
4063  std::string s = SymbolDefState(i);
4064  if (s.empty())
4065  s = "(SgAsmGenericSymbol::SymbolDefState)" + boost::lexical_cast<std::string>(i);
4066  if (boost::starts_with(s, strip))
4067  s = s.substr(strip.size());
4068  return s;
4069  }
4070 
4071  const std::vector<int64_t>& SymbolDefState() {
4072  static const int64_t values[] = {
4073  0L,
4074  1L,
4075  2L
4076  };
4077  static const std::vector<int64_t> retval(values, values + 3);
4078  return retval;
4079  }
4080 
4081 }}
4082 
4083 namespace Rose {
4084  std::string stringifySgAsmGenericSymbolSymbolDefState(int64_t i, const char *strip, bool canonic) {
4085  std::string retval = stringify::SgAsmGenericSymbol::SymbolDefState(i);
4086  if (retval.empty()) {
4087  retval = "(SgAsmGenericSymbol::SymbolDefState)" + boost::lexical_cast<std::string>(i);
4088  } else {
4089  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4090  retval = retval.substr(strlen(strip));
4091  if (canonic)
4092  retval = "SgAsmGenericSymbol::SymbolDefState::" + retval;
4093  }
4094  return retval;
4095  }
4096 
4097  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolDefState() {
4099  }
4100 }
4101 
4102 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4103 // /src/ROSETTA/src/binaryInstruction.C line 14039
4104 namespace stringify { namespace SgAsmGenericSymbol {
4105  const char* SymbolType(int64_t i) {
4106  switch (i) {
4107  case 0L: return "SYM_NO_TYPE";
4108  case 1L: return "SYM_DATA";
4109  case 2L: return "SYM_FUNC";
4110  case 3L: return "SYM_SECTION";
4111  case 4L: return "SYM_FILE";
4112  case 5L: return "SYM_ARRAY";
4113  case 6L: return "SYM_TLS";
4114  case 7L: return "SYM_REGISTER";
4115  case 8L: return "SYM_COMMON";
4116  case 9L: return "SYM_IFUNC";
4117  default: return "";
4118  }
4119  }
4120 
4121  std::string SymbolType(int64_t i, const std::string &strip) {
4122  std::string s = SymbolType(i);
4123  if (s.empty())
4124  s = "(SgAsmGenericSymbol::SymbolType)" + boost::lexical_cast<std::string>(i);
4125  if (boost::starts_with(s, strip))
4126  s = s.substr(strip.size());
4127  return s;
4128  }
4129 
4130  const std::vector<int64_t>& SymbolType() {
4131  static const int64_t values[] = {
4132  0L,
4133  1L,
4134  2L,
4135  3L,
4136  4L,
4137  5L,
4138  6L,
4139  7L,
4140  8L,
4141  9L
4142  };
4143  static const std::vector<int64_t> retval(values, values + 10);
4144  return retval;
4145  }
4146 
4147 }}
4148 
4149 namespace Rose {
4150  std::string stringifySgAsmGenericSymbolSymbolType(int64_t i, const char *strip, bool canonic) {
4151  std::string retval = stringify::SgAsmGenericSymbol::SymbolType(i);
4152  if (retval.empty()) {
4153  retval = "(SgAsmGenericSymbol::SymbolType)" + boost::lexical_cast<std::string>(i);
4154  } else {
4155  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4156  retval = retval.substr(strlen(strip));
4157  if (canonic)
4158  retval = "SgAsmGenericSymbol::SymbolType::" + retval;
4159  }
4160  return retval;
4161  }
4162 
4163  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolType() {
4165  }
4166 }
4167 
4168 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4169 // /src/ROSETTA/src/binaryInstruction.C line 14053
4170 namespace stringify { namespace SgAsmGenericSymbol {
4171  const char* SymbolBinding(int64_t i) {
4172  switch (i) {
4173  case 0L: return "SYM_NO_BINDING";
4174  case 1L: return "SYM_LOCAL";
4175  case 2L: return "SYM_GLOBAL";
4176  case 3L: return "SYM_WEAK";
4177  default: return "";
4178  }
4179  }
4180 
4181  std::string SymbolBinding(int64_t i, const std::string &strip) {
4182  std::string s = SymbolBinding(i);
4183  if (s.empty())
4184  s = "(SgAsmGenericSymbol::SymbolBinding)" + boost::lexical_cast<std::string>(i);
4185  if (boost::starts_with(s, strip))
4186  s = s.substr(strip.size());
4187  return s;
4188  }
4189 
4190  const std::vector<int64_t>& SymbolBinding() {
4191  static const int64_t values[] = {
4192  0L,
4193  1L,
4194  2L,
4195  3L
4196  };
4197  static const std::vector<int64_t> retval(values, values + 4);
4198  return retval;
4199  }
4200 
4201 }}
4202 
4203 namespace Rose {
4204  std::string stringifySgAsmGenericSymbolSymbolBinding(int64_t i, const char *strip, bool canonic) {
4205  std::string retval = stringify::SgAsmGenericSymbol::SymbolBinding(i);
4206  if (retval.empty()) {
4207  retval = "(SgAsmGenericSymbol::SymbolBinding)" + boost::lexical_cast<std::string>(i);
4208  } else {
4209  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4210  retval = retval.substr(strlen(strip));
4211  if (canonic)
4212  retval = "SgAsmGenericSymbol::SymbolBinding::" + retval;
4213  }
4214  return retval;
4215  }
4216 
4217  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolBinding() {
4219  }
4220 }
4221 
4222 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4223 // /src/ROSETTA/src/binaryInstruction.C line 14586
4224 namespace stringify { namespace SgAsmGenericSection {
4225  const char* SectionPurpose(int64_t i) {
4226  switch (i) {
4227  case 0L: return "SP_UNSPECIFIED";
4228  case 1L: return "SP_PROGRAM";
4229  case 2L: return "SP_HEADER";
4230  case 3L: return "SP_SYMTAB";
4231  case 4L: return "SP_OTHER";
4232  default: return "";
4233  }
4234  }
4235 
4236  std::string SectionPurpose(int64_t i, const std::string &strip) {
4237  std::string s = SectionPurpose(i);
4238  if (s.empty())
4239  s = "(SgAsmGenericSection::SectionPurpose)" + boost::lexical_cast<std::string>(i);
4240  if (boost::starts_with(s, strip))
4241  s = s.substr(strip.size());
4242  return s;
4243  }
4244 
4245  const std::vector<int64_t>& SectionPurpose() {
4246  static const int64_t values[] = {
4247  0L,
4248  1L,
4249  2L,
4250  3L,
4251  4L
4252  };
4253  static const std::vector<int64_t> retval(values, values + 5);
4254  return retval;
4255  }
4256 
4257 }}
4258 
4259 namespace Rose {
4260  std::string stringifySgAsmGenericSectionSectionPurpose(int64_t i, const char *strip, bool canonic) {
4261  std::string retval = stringify::SgAsmGenericSection::SectionPurpose(i);
4262  if (retval.empty()) {
4263  retval = "(SgAsmGenericSection::SectionPurpose)" + boost::lexical_cast<std::string>(i);
4264  } else {
4265  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4266  retval = retval.substr(strlen(strip));
4267  if (canonic)
4268  retval = "SgAsmGenericSection::SectionPurpose::" + retval;
4269  }
4270  return retval;
4271  }
4272 
4273  const std::vector<int64_t>& stringifySgAsmGenericSectionSectionPurpose() {
4275  }
4276 }
4277 
4278 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4279 // /src/ROSETTA/src/binaryInstruction.C line 15423
4280 namespace stringify { namespace SgAsmGenericFile {
4281  const char* AddressSpace(int64_t i) {
4282  switch (i) {
4283  case 1L: return "ADDRSP_MEMORY";
4284  case 2L: return "ADDRSP_FILE";
4285  case 3L: return "ADDRSP_ALL";
4286  default: return "";
4287  }
4288  }
4289 
4290  std::string AddressSpace(int64_t i, const std::string &strip) {
4291  std::string s = AddressSpace(i);
4292  if (s.empty())
4293  s = "(SgAsmGenericFile::AddressSpace)" + boost::lexical_cast<std::string>(i);
4294  if (boost::starts_with(s, strip))
4295  s = s.substr(strip.size());
4296  return s;
4297  }
4298 
4299  const std::vector<int64_t>& AddressSpace() {
4300  static const int64_t values[] = {
4301  1L,
4302  2L,
4303  3L
4304  };
4305  static const std::vector<int64_t> retval(values, values + 3);
4306  return retval;
4307  }
4308 
4309 }}
4310 
4311 namespace Rose {
4312  std::string stringifySgAsmGenericFileAddressSpace(int64_t i, const char *strip, bool canonic) {
4313  std::string retval = stringify::SgAsmGenericFile::AddressSpace(i);
4314  if (retval.empty()) {
4315  retval = "(SgAsmGenericFile::AddressSpace)" + boost::lexical_cast<std::string>(i);
4316  } else {
4317  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4318  retval = retval.substr(strlen(strip));
4319  if (canonic)
4320  retval = "SgAsmGenericFile::AddressSpace::" + retval;
4321  }
4322  return retval;
4323  }
4324 
4325  const std::vector<int64_t>& stringifySgAsmGenericFileAddressSpace() {
4327  }
4328 }
4329 
4330 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4331 // /src/ROSETTA/src/binaryInstruction.C line 15430
4332 namespace stringify { namespace SgAsmGenericFile {
4333  const char* Elasticity(int64_t i) {
4334  switch (i) {
4335  case 0L: return "ELASTIC_NONE";
4336  case 1L: return "ELASTIC_UNREF";
4337  case 2L: return "ELASTIC_HOLE";
4338  default: return "";
4339  }
4340  }
4341 
4342  std::string Elasticity(int64_t i, const std::string &strip) {
4343  std::string s = Elasticity(i);
4344  if (s.empty())
4345  s = "(SgAsmGenericFile::Elasticity)" + boost::lexical_cast<std::string>(i);
4346  if (boost::starts_with(s, strip))
4347  s = s.substr(strip.size());
4348  return s;
4349  }
4350 
4351  const std::vector<int64_t>& Elasticity() {
4352  static const int64_t values[] = {
4353  0L,
4354  1L,
4355  2L
4356  };
4357  static const std::vector<int64_t> retval(values, values + 3);
4358  return retval;
4359  }
4360 
4361 }}
4362 
4363 namespace Rose {
4364  std::string stringifySgAsmGenericFileElasticity(int64_t i, const char *strip, bool canonic) {
4365  std::string retval = stringify::SgAsmGenericFile::Elasticity(i);
4366  if (retval.empty()) {
4367  retval = "(SgAsmGenericFile::Elasticity)" + boost::lexical_cast<std::string>(i);
4368  } else {
4369  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4370  retval = retval.substr(strlen(strip));
4371  if (canonic)
4372  retval = "SgAsmGenericFile::Elasticity::" + retval;
4373  }
4374  return retval;
4375  }
4376 
4377  const std::vector<int64_t>& stringifySgAsmGenericFileElasticity() {
4379  }
4380 }
4381 
4382 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4383 // /src/ROSETTA/src/binaryInstruction.C line 15830
4384 namespace stringify { namespace SgAsmExecutableFileFormat {
4385  const char* ExecFamily(int64_t i) {
4386  switch (i) {
4387  case 0L: return "FAMILY_UNSPECIFIED";
4388  case 1L: return "FAMILY_DOS";
4389  case 2L: return "FAMILY_ELF";
4390  case 3L: return "FAMILY_LE";
4391  case 4L: return "FAMILY_LX";
4392  case 5L: return "FAMILY_NE";
4393  case 6L: return "FAMILY_PE";
4394  default: return "";
4395  }
4396  }
4397 
4398  std::string ExecFamily(int64_t i, const std::string &strip) {
4399  std::string s = ExecFamily(i);
4400  if (s.empty())
4401  s = "(SgAsmExecutableFileFormat::ExecFamily)" + boost::lexical_cast<std::string>(i);
4402  if (boost::starts_with(s, strip))
4403  s = s.substr(strip.size());
4404  return s;
4405  }
4406 
4407  const std::vector<int64_t>& ExecFamily() {
4408  static const int64_t values[] = {
4409  0L,
4410  1L,
4411  2L,
4412  3L,
4413  4L,
4414  5L,
4415  6L
4416  };
4417  static const std::vector<int64_t> retval(values, values + 7);
4418  return retval;
4419  }
4420 
4421 }}
4422 
4423 namespace Rose {
4424  std::string stringifySgAsmExecutableFileFormatExecFamily(int64_t i, const char *strip, bool canonic) {
4425  std::string retval = stringify::SgAsmExecutableFileFormat::ExecFamily(i);
4426  if (retval.empty()) {
4427  retval = "(SgAsmExecutableFileFormat::ExecFamily)" + boost::lexical_cast<std::string>(i);
4428  } else {
4429  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4430  retval = retval.substr(strlen(strip));
4431  if (canonic)
4432  retval = "SgAsmExecutableFileFormat::ExecFamily::" + retval;
4433  }
4434  return retval;
4435  }
4436 
4437  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecFamily() {
4439  }
4440 }
4441 
4442 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4443 // /src/ROSETTA/src/binaryInstruction.C line 15841
4444 namespace stringify { namespace SgAsmExecutableFileFormat {
4445  const char* ExecABI(int64_t i) {
4446  switch (i) {
4447  case 0L: return "ABI_UNSPECIFIED";
4448  case 1L: return "ABI_OTHER";
4449  case 2L: return "ABI_86OPEN";
4450  case 3L: return "ABI_AIX";
4451  case 4L: return "ABI_ARM";
4452  case 5L: return "ABI_FREEBSD";
4453  case 6L: return "ABI_HPUX";
4454  case 7L: return "ABI_IRIX";
4455  case 8L: return "ABI_HURD";
4456  case 9L: return "ABI_LINUX";
4457  case 10L: return "ABI_MODESTO";
4458  case 11L: return "ABI_MONTEREY";
4459  case 12L: return "ABI_MSDOS";
4460  case 13L: return "ABI_NT";
4461  case 14L: return "ABI_NETBSD";
4462  case 15L: return "ABI_OS2";
4463  case 16L: return "ABI_SOLARIS";
4464  case 17L: return "ABI_SYSV";
4465  case 18L: return "ABI_TRU64";
4466  case 19L: return "ABI_WIN386";
4467  default: return "";
4468  }
4469  }
4470 
4471  std::string ExecABI(int64_t i, const std::string &strip) {
4472  std::string s = ExecABI(i);
4473  if (s.empty())
4474  s = "(SgAsmExecutableFileFormat::ExecABI)" + boost::lexical_cast<std::string>(i);
4475  if (boost::starts_with(s, strip))
4476  s = s.substr(strip.size());
4477  return s;
4478  }
4479 
4480  const std::vector<int64_t>& ExecABI() {
4481  static const int64_t values[] = {
4482  0L,
4483  1L,
4484  2L,
4485  3L,
4486  4L,
4487  5L,
4488  6L,
4489  7L,
4490  8L,
4491  9L,
4492  10L,
4493  11L,
4494  12L,
4495  13L,
4496  14L,
4497  15L,
4498  16L,
4499  17L,
4500  18L,
4501  19L
4502  };
4503  static const std::vector<int64_t> retval(values, values + 20);
4504  return retval;
4505  }
4506 
4507 }}
4508 
4509 namespace Rose {
4510  std::string stringifySgAsmExecutableFileFormatExecABI(int64_t i, const char *strip, bool canonic) {
4511  std::string retval = stringify::SgAsmExecutableFileFormat::ExecABI(i);
4512  if (retval.empty()) {
4513  retval = "(SgAsmExecutableFileFormat::ExecABI)" + boost::lexical_cast<std::string>(i);
4514  } else {
4515  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4516  retval = retval.substr(strlen(strip));
4517  if (canonic)
4518  retval = "SgAsmExecutableFileFormat::ExecABI::" + retval;
4519  }
4520  return retval;
4521  }
4522 
4523  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecABI() {
4525  }
4526 }
4527 
4528 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4529 // /src/ROSETTA/src/binaryInstruction.C line 15865
4530 namespace stringify { namespace SgAsmExecutableFileFormat {
4531  const char* InsSetArchitecture(int64_t i) {
4532  switch (i) {
4533  case 0L: return "ISA_UNSPECIFIED";
4534  case 256L: return "ISA_IA32_Family";
4535  case 257L: return "ISA_IA32_286";
4536  case 258L: return "ISA_IA32_386";
4537  case 259L: return "ISA_IA32_486";
4538  case 260L: return "ISA_IA32_Pentium";
4539  case 261L: return "ISA_IA32_Cyrix6x86";
4540  case 262L: return "ISA_IA32_AMDK5";
4541  case 263L: return "ISA_IA32_PentiumPro";
4542  case 264L: return "ISA_IA32_PentiumII";
4543  case 265L: return "ISA_IA32_Athlon";
4544  case 266L: return "ISA_IA32_Pentium4";
4545  case 267L: return "ISA_IA32_PentiumM";
4546  case 512L: return "ISA_X8664_Family";
4547  case 513L: return "ISA_X8664_Athlon64";
4548  case 514L: return "ISA_X8664_Prescott";
4549  case 515L: return "ISA_X8664_IntelCore";
4550  case 516L: return "ISA_X8664_AMDPhenom";
4551  case 768L: return "ISA_SPARC_Family";
4552  case 769L: return "ISA_SPARC_V7";
4553  case 770L: return "ISA_SPARC_V8";
4554  case 771L: return "ISA_SPARC_V8E";
4555  case 772L: return "ISA_SPARC_V9";
4556  case 773L: return "ISA_SPARC_V9JPS1";
4557  case 774L: return "ISA_SPARC_V9UA";
4558  case 775L: return "ISA_SPARC_V9JPS2";
4559  case 1024L: return "ISA_M68K_Family";
4560  case 1025L: return "ISA_M68K_68000";
4561  case 1026L: return "ISA_M68K_68EC000";
4562  case 1027L: return "ISA_M68K_68HC000";
4563  case 1028L: return "ISA_M68K_68008";
4564  case 1029L: return "ISA_M68K_68010";
4565  case 1030L: return "ISA_M68K_68012";
4566  case 1031L: return "ISA_M68K_68020";
4567  case 1032L: return "ISA_M68K_68EC020";
4568  case 1033L: return "ISA_M68K_68030";
4569  case 1034L: return "ISA_M68K_68EC030";
4570  case 1035L: return "ISA_M68K_68040";
4571  case 1036L: return "ISA_M68K_68EC040";
4572  case 1037L: return "ISA_M68K_68LC040";
4573  case 1038L: return "ISA_M68K_68060";
4574  case 1039L: return "ISA_M68K_ColdFire";
4575  case 1040L: return "ISA_M68K_DragonBall";
4576  case 1280L: return "ISA_M88K_Family";
4577  case 1281L: return "ISA_M88K_88100";
4578  case 1282L: return "ISA_M88K_88110";
4579  case 1283L: return "ISA_M88K_88110MP";
4580  case 1284L: return "ISA_M88K_88120";
4581  case 1536L: return "ISA_MIPS_Family";
4582  case 1537L: return "ISA_MIPS_MarkI";
4583  case 1538L: return "ISA_MIPS_MarkII";
4584  case 1539L: return "ISA_MIPS_MarkIII";
4585  case 1540L: return "ISA_MIPS_R2000";
4586  case 1541L: return "ISA_MIPS_R3000";
4587  case 1542L: return "ISA_MIPS_R4000";
4588  case 1543L: return "ISA_MIPS_R4200";
4589  case 1544L: return "ISA_MIPS_R4300";
4590  case 1545L: return "ISA_MIPS_R4600";
4591  case 1546L: return "ISA_MIPS_R4650";
4592  case 1547L: return "ISA_MIPS_R4700";
4593  case 1548L: return "ISA_MIPS_R5000";
4594  case 1549L: return "ISA_MIPS_RM7000";
4595  case 1550L: return "ISA_MIPS_R8000";
4596  case 1551L: return "ISA_MIPS_R10000";
4597  case 1552L: return "ISA_MIPS_R12000";
4598  case 1553L: return "ISA_MIPS_R14000";
4599  case 1554L: return "ISA_MIPS_R16000";
4600  case 1555L: return "ISA_MIPS_R16000A";
4601  case 1556L: return "ISA_MIPS_16";
4602  case 1557L: return "ISA_MIPS_FPU";
4603  case 1558L: return "ISA_MIPS_16FPU";
4604  case 1792L: return "ISA_I860_Family";
4605  case 1793L: return "ISA_I860_860XR";
4606  case 1794L: return "ISA_I860_860XP";
4607  case 2048L: return "ISA_IA64_Family";
4608  case 2049L: return "ISA_IA64_Itanium";
4609  case 2050L: return "ISA_IA64_Itanium2";
4610  case 2304L: return "ISA_ARM_Family";
4611  case 2305L: return "ISA_ARM_ARM1";
4612  case 2306L: return "ISA_ARM_ARM2";
4613  case 2307L: return "ISA_ARM_ARM3";
4614  case 2308L: return "ISA_ARM_ARM6";
4615  case 2309L: return "ISA_ARM_ARM7";
4616  case 2310L: return "ISA_ARM_ARM7TDMI";
4617  case 2311L: return "ISA_ARM_StrongARM";
4618  case 2312L: return "ISA_ARM_ARM8";
4619  case 2313L: return "ISA_ARM_ARM9TDMI";
4620  case 2314L: return "ISA_ARM_ARM9E";
4621  case 2315L: return "ISA_ARM_ARM10E";
4622  case 2316L: return "ISA_ARM_XScale";
4623  case 2317L: return "ISA_ARM_ARM11";
4624  case 2318L: return "ISA_ARM_Cortex";
4625  case 61440L: return "ISA_OTHER_Family";
4626  case 61441L: return "ISA_ATT_WE_32100";
4627  case 61442L: return "ISA_IBM_System_370";
4628  case 61443L: return "ISA_HPPA";
4629  case 61444L: return "ISA_Fujitsu_VPP500";
4630  case 61445L: return "ISA_Sun_v8plus";
4631  case 61446L: return "ISA_PowerPC";
4632  case 61447L: return "ISA_PowerPC_64bit";
4633  case 61448L: return "ISA_IBM_S390";
4634  case 61449L: return "ISA_NEC_V800_series";
4635  case 61450L: return "ISA_Fujitsu_FR20";
4636  case 61451L: return "ISA_TRW_RH_32";
4637  case 61452L: return "ISA_Motorola_RCE";
4638  case 61454L: return "ISA_Digital_Alpha_fake";
4639  case 61455L: return "ISA_Hitachi_SH";
4640  case 61456L: return "ISA_Siemens_Tricore";
4641  case 61457L: return "ISA_Argonaut_RISC_Core";
4642  case 61458L: return "ISA_Hitachi_H8_300";
4643  case 61459L: return "ISA_Hitachi_H8_300H";
4644  case 61460L: return "ISA_Hitachi_H8S";
4645  case 61461L: return "ISA_Hitachi_H8_500";
4646  case 61462L: return "ISA_Stanford_MIPS_X";
4647  case 61463L: return "ISA_Motorola_M68HC12";
4648  case 61464L: return "ISA_Fujitsu_MMA_Multimedia_Accelerator";
4649  case 61465L: return "ISA_Siemens_PCP";
4650  case 61466L: return "ISA_Sony_nCPU_embeeded_RISC";
4651  case 61467L: return "ISA_Denso_NDR1_microprocessor";
4652  case 61468L: return "ISA_Motorola_Start_Core_processor";
4653  case 61469L: return "ISA_Toyota_ME16_processor";
4654  case 61470L: return "ISA_STMicroelectronic_ST100_processor";
4655  case 61471L: return "ISA_Advanced_Logic_Corp_Tinyj_emb_family";
4656  case 61472L: return "ISA_AMD_x86_64_architecture";
4657  case 61473L: return "ISA_Sony_DSP_Processor";
4658  case 61474L: return "ISA_Siemens_FX66_microcontroller";
4659  case 61475L: return "ISA_STMicroelectronics_ST9_plus_8_16_microcontroller";
4660  case 61476L: return "ISA_STMicroelectronics_ST7_8bit_microcontroller";
4661  case 61477L: return "ISA_Motorola_MC68HC16_microcontroller";
4662  case 61478L: return "ISA_Motorola_MC68HC11_microcontroller";
4663  case 61479L: return "ISA_Motorola_MC68HC08_microcontroller";
4664  case 61480L: return "ISA_Motorola_MC68HC05_microcontroller";
4665  case 61481L: return "ISA_Silicon_Graphics_SVx";
4666  case 61482L: return "ISA_STMicroelectronics_ST19_8bit_microcontroller";
4667  case 61483L: return "ISA_Digital_VAX";
4668  case 61484L: return "ISA_Axis_Communications_32bit_embedded_processor";
4669  case 61485L: return "ISA_Infineon_Technologies_32bit_embedded_processor";
4670  case 61486L: return "ISA_Element_14_64bit_DSP_Processor";
4671  case 61487L: return "ISA_LSI_Logic_16bit_DSP_Processor";
4672  case 61488L: return "ISA_Donald_Knuths_educational_64bit_processor";
4673  case 61489L: return "ISA_Harvard_University_machine_independent_object_files";
4674  case 61490L: return "ISA_SiTera_Prism";
4675  case 61491L: return "ISA_Atmel_AVR_8bit_microcontroller";
4676  case 61492L: return "ISA_Fujitsu_FR30";
4677  case 61493L: return "ISA_Mitsubishi_D10V";
4678  case 61494L: return "ISA_Mitsubishi_D30V";
4679  case 61495L: return "ISA_NEC_v850";
4680  case 61496L: return "ISA_Mitsubishi_M32R";
4681  case 61497L: return "ISA_Matsushita_MN10300";
4682  case 61498L: return "ISA_Matsushita_MN10200";
4683  case 61499L: return "ISA_picoJava";
4684  case 61500L: return "ISA_OpenRISC_32bit_embedded_processor";
4685  case 61501L: return "ISA_ARC_Cores_Tangent_A5";
4686  case 61502L: return "ISA_Tensilica_Xtensa_Architecture";
4687  case 61503L: return "ISA_Digital_Alpha";
4688  case 61504L: return "ISA_Matsushita_AM33";
4689  case 61505L: return "ISA_EFI_ByteCode";
4690  case 65280L: return "ISA_FAMILY_MASK";
4691  case 65535L: return "ISA_OTHER";
4692  default: return "";
4693  }
4694  }
4695 
4696  std::string InsSetArchitecture(int64_t i, const std::string &strip) {
4697  std::string s = InsSetArchitecture(i);
4698  if (s.empty())
4699  s = "(SgAsmExecutableFileFormat::InsSetArchitecture)" + boost::lexical_cast<std::string>(i);
4700  if (boost::starts_with(s, strip))
4701  s = s.substr(strip.size());
4702  return s;
4703  }
4704 
4705  const std::vector<int64_t>& InsSetArchitecture() {
4706  static const int64_t values[] = {
4707  0L,
4708  256L,
4709  257L,
4710  258L,
4711  259L,
4712  260L,
4713  261L,
4714  262L,
4715  263L,
4716  264L,
4717  265L,
4718  266L,
4719  267L,
4720  512L,
4721  513L,
4722  514L,
4723  515L,
4724  516L,
4725  768L,
4726  769L,
4727  770L,
4728  771L,
4729  772L,
4730  773L,
4731  774L,
4732  775L,
4733  1024L,
4734  1025L,
4735  1026L,
4736  1027L,
4737  1028L,
4738  1029L,
4739  1030L,
4740  1031L,
4741  1032L,
4742  1033L,
4743  1034L,
4744  1035L,
4745  1036L,
4746  1037L,
4747  1038L,
4748  1039L,
4749  1040L,
4750  1280L,
4751  1281L,
4752  1282L,
4753  1283L,
4754  1284L,
4755  1536L,
4756  1537L,
4757  1538L,
4758  1539L,
4759  1540L,
4760  1541L,
4761  1542L,
4762  1543L,
4763  1544L,
4764  1545L,
4765  1546L,
4766  1547L,
4767  1548L,
4768  1549L,
4769  1550L,
4770  1551L,
4771  1552L,
4772  1553L,
4773  1554L,
4774  1555L,
4775  1556L,
4776  1557L,
4777  1558L,
4778  1792L,
4779  1793L,
4780  1794L,
4781  2048L,
4782  2049L,
4783  2050L,
4784  2304L,
4785  2305L,
4786  2306L,
4787  2307L,
4788  2308L,
4789  2309L,
4790  2310L,
4791  2311L,
4792  2312L,
4793  2313L,
4794  2314L,
4795  2315L,
4796  2316L,
4797  2317L,
4798  2318L,
4799  61440L,
4800  61441L,
4801  61442L,
4802  61443L,
4803  61444L,
4804  61445L,
4805  61446L,
4806  61447L,
4807  61448L,
4808  61449L,
4809  61450L,
4810  61451L,
4811  61452L,
4812  61454L,
4813  61455L,
4814  61456L,
4815  61457L,
4816  61458L,
4817  61459L,
4818  61460L,
4819  61461L,
4820  61462L,
4821  61463L,
4822  61464L,
4823  61465L,
4824  61466L,
4825  61467L,
4826  61468L,
4827  61469L,
4828  61470L,
4829  61471L,
4830  61472L,
4831  61473L,
4832  61474L,
4833  61475L,
4834  61476L,
4835  61477L,
4836  61478L,
4837  61479L,
4838  61480L,
4839  61481L,
4840  61482L,
4841  61483L,
4842  61484L,
4843  61485L,
4844  61486L,
4845  61487L,
4846  61488L,
4847  61489L,
4848  61490L,
4849  61491L,
4850  61492L,
4851  61493L,
4852  61494L,
4853  61495L,
4854  61496L,
4855  61497L,
4856  61498L,
4857  61499L,
4858  61500L,
4859  61501L,
4860  61502L,
4861  61503L,
4862  61504L,
4863  61505L,
4864  65280L,
4865  65535L
4866  };
4867  static const std::vector<int64_t> retval(values, values + 159);
4868  return retval;
4869  }
4870 
4871 }}
4872 
4873 namespace Rose {
4874  std::string stringifySgAsmExecutableFileFormatInsSetArchitecture(int64_t i, const char *strip, bool canonic) {
4876  if (retval.empty()) {
4877  retval = "(SgAsmExecutableFileFormat::InsSetArchitecture)" + boost::lexical_cast<std::string>(i);
4878  } else {
4879  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4880  retval = retval.substr(strlen(strip));
4881  if (canonic)
4882  retval = "SgAsmExecutableFileFormat::InsSetArchitecture::" + retval;
4883  }
4884  return retval;
4885  }
4886 
4887  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatInsSetArchitecture() {
4889  }
4890 }
4891 
4892 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4893 // /src/ROSETTA/src/binaryInstruction.C line 16044
4894 namespace stringify { namespace SgAsmExecutableFileFormat {
4895  const char* ExecPurpose(int64_t i) {
4896  switch (i) {
4897  case 0L: return "PURPOSE_UNSPECIFIED";
4898  case 1L: return "PURPOSE_OTHER";
4899  case 2L: return "PURPOSE_EXECUTABLE";
4900  case 3L: return "PURPOSE_LIBRARY";
4901  case 4L: return "PURPOSE_CORE_DUMP";
4902  case 5L: return "PURPOSE_OS_SPECIFIC";
4903  case 6L: return "PURPOSE_PROC_SPECIFIC";
4904  default: return "";
4905  }
4906  }
4907 
4908  std::string ExecPurpose(int64_t i, const std::string &strip) {
4909  std::string s = ExecPurpose(i);
4910  if (s.empty())
4911  s = "(SgAsmExecutableFileFormat::ExecPurpose)" + boost::lexical_cast<std::string>(i);
4912  if (boost::starts_with(s, strip))
4913  s = s.substr(strip.size());
4914  return s;
4915  }
4916 
4917  const std::vector<int64_t>& ExecPurpose() {
4918  static const int64_t values[] = {
4919  0L,
4920  1L,
4921  2L,
4922  3L,
4923  4L,
4924  5L,
4925  6L
4926  };
4927  static const std::vector<int64_t> retval(values, values + 7);
4928  return retval;
4929  }
4930 
4931 }}
4932 
4933 namespace Rose {
4934  std::string stringifySgAsmExecutableFileFormatExecPurpose(int64_t i, const char *strip, bool canonic) {
4935  std::string retval = stringify::SgAsmExecutableFileFormat::ExecPurpose(i);
4936  if (retval.empty()) {
4937  retval = "(SgAsmExecutableFileFormat::ExecPurpose)" + boost::lexical_cast<std::string>(i);
4938  } else {
4939  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4940  retval = retval.substr(strlen(strip));
4941  if (canonic)
4942  retval = "SgAsmExecutableFileFormat::ExecPurpose::" + retval;
4943  }
4944  return retval;
4945  }
4946 
4947  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecPurpose() {
4949  }
4950 }
4951 
4952 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4953 // /src/backend/asmUnparser/BinaryUnparserBase.h line 37
4954 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace ArrowMargin {
4955  const char* Flags(int64_t i) {
4956  switch (i) {
4957  case 1L: return "POINTABLE_ENTITY_START";
4958  case 2L: return "POINTABLE_ENTITY_END";
4959  case 4L: return "POINTABLE_ENTITY_INSIDE";
4960  case 8L: return "ALWAYS_RENDER";
4961  default: return "";
4962  }
4963  }
4964 
4965  std::string Flags(int64_t i, const std::string &strip) {
4966  std::string s = Flags(i);
4967  if (s.empty())
4968  s = "(Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags)" + boost::lexical_cast<std::string>(i);
4969  if (boost::starts_with(s, strip))
4970  s = s.substr(strip.size());
4971  return s;
4972  }
4973 
4974  const std::vector<int64_t>& Flags() {
4975  static const int64_t values[] = {
4976  1L,
4977  2L,
4978  4L,
4979  8L
4980  };
4981  static const std::vector<int64_t> retval(values, values + 4);
4982  return retval;
4983  }
4984 
4985 }}}}}
4986 
4987 namespace Rose {
4988  std::string stringifyBinaryAnalysisUnparserArrowMarginFlags(int64_t i, const char *strip, bool canonic) {
4990  if (retval.empty()) {
4991  retval = "(Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags)" + boost::lexical_cast<std::string>(i);
4992  } else {
4993  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4994  retval = retval.substr(strlen(strip));
4995  if (canonic)
4996  retval = "Rose::BinaryAnalysis::Unparser::ArrowMargin::Flags::" + retval;
4997  }
4998  return retval;
4999  }
5000 
5001  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserArrowMarginFlags() {
5003  }
5004 }
5005 
5006 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5007 // /src/backend/asmUnparser/AsmUnparser.h line 251
5008 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AsmUnparser {
5009  const char* Organization(int64_t i) {
5010  switch (i) {
5011  case 0L: return "ORGANIZED_BY_AST";
5012  case 1L: return "ORGANIZED_BY_ADDRESS";
5013  default: return "";
5014  }
5015  }
5016 
5017  std::string Organization(int64_t i, const std::string &strip) {
5018  std::string s = Organization(i);
5019  if (s.empty())
5020  s = "(Rose::BinaryAnalysis::AsmUnparser::Organization)" + boost::lexical_cast<std::string>(i);
5021  if (boost::starts_with(s, strip))
5022  s = s.substr(strip.size());
5023  return s;
5024  }
5025 
5026  const std::vector<int64_t>& Organization() {
5027  static const int64_t values[] = {
5028  0L,
5029  1L
5030  };
5031  static const std::vector<int64_t> retval(values, values + 2);
5032  return retval;
5033  }
5034 
5035 }}}}
5036 
5037 namespace Rose {
5038  std::string stringifyBinaryAnalysisAsmUnparserOrganization(int64_t i, const char *strip, bool canonic) {
5040  if (retval.empty()) {
5041  retval = "(Rose::BinaryAnalysis::AsmUnparser::Organization)" + boost::lexical_cast<std::string>(i);
5042  } else {
5043  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5044  retval = retval.substr(strlen(strip));
5045  if (canonic)
5046  retval = "Rose::BinaryAnalysis::AsmUnparser::Organization::" + retval;
5047  }
5048  return retval;
5049  }
5050 
5051  const std::vector<int64_t>& stringifyBinaryAnalysisAsmUnparserOrganization() {
5053  }
5054 }
5055 
5056 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5057 // /src/backend/asmUnparser/AsmUnparser_compat.h line 46
5058 namespace stringify {
5059  const char* ArmSignForExpressionUnparsing(int64_t i) {
5060  switch (i) {
5061  case 0L: return "arm_sign_none";
5062  case 1L: return "arm_sign_plus";
5063  case 2L: return "arm_sign_minus";
5064  default: return "";
5065  }
5066  }
5067 
5068  std::string ArmSignForExpressionUnparsing(int64_t i, const std::string &strip) {
5069  std::string s = ArmSignForExpressionUnparsing(i);
5070  if (s.empty())
5071  s = "(ArmSignForExpressionUnparsing)" + boost::lexical_cast<std::string>(i);
5072  if (boost::starts_with(s, strip))
5073  s = s.substr(strip.size());
5074  return s;
5075  }
5076 
5077  const std::vector<int64_t>& ArmSignForExpressionUnparsing() {
5078  static const int64_t values[] = {
5079  0L,
5080  1L,
5081  2L
5082  };
5083  static const std::vector<int64_t> retval(values, values + 3);
5084  return retval;
5085  }
5086 
5087 }
5088 
5089 namespace Rose {
5090  std::string stringifyArmSignForExpressionUnparsing(int64_t i, const char *strip, bool canonic) {
5091  std::string retval = stringify::ArmSignForExpressionUnparsing(i);
5092  if (retval.empty()) {
5093  retval = "(ArmSignForExpressionUnparsing)" + boost::lexical_cast<std::string>(i);
5094  } else {
5095  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5096  retval = retval.substr(strlen(strip));
5097  if (canonic)
5098  retval = "ArmSignForExpressionUnparsing::" + retval;
5099  }
5100  return retval;
5101  }
5102 
5103  const std::vector<int64_t>& stringifyArmSignForExpressionUnparsing() {
5105  }
5106 }
5107 
5108 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5109 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 31
5110 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
5111  const char* OutputPart(int64_t i) {
5112  switch (i) {
5113  case 0L: return "FIRST_LINE";
5114  case 1L: return "LAST_LINE";
5115  case 2L: return "MIDDLE_LINE";
5116  case 3L: return "INTER_LINE";
5117  default: return "";
5118  }
5119  }
5120 
5121  std::string OutputPart(int64_t i, const std::string &strip) {
5122  std::string s = OutputPart(i);
5123  if (s.empty())
5124  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart)" + boost::lexical_cast<std::string>(i);
5125  if (boost::starts_with(s, strip))
5126  s = s.substr(strip.size());
5127  return s;
5128  }
5129 
5130  const std::vector<int64_t>& OutputPart() {
5131  static const int64_t values[] = {
5132  0L,
5133  1L,
5134  2L,
5135  3L
5136  };
5137  static const std::vector<int64_t> retval(values, values + 4);
5138  return retval;
5139  }
5140 
5141 }}}}}
5142 
5143 namespace Rose {
5144  std::string stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart(int64_t i, const char *strip, bool canonic) {
5146  if (retval.empty()) {
5147  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart)" + boost::lexical_cast<std::string>(i);
5148  } else {
5149  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5150  retval = retval.substr(strlen(strip));
5151  if (canonic)
5152  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::OutputPart::" + retval;
5153  }
5154  return retval;
5155  }
5156 
5157  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart() {
5159  }
5160 }
5161 
5162 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5163 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 59
5164 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
5165  const char* ArrowStylePreset(int64_t i) {
5166  switch (i) {
5167  case 0L: return "UNICODE_1";
5168  case 1L: return "UNICODE_2";
5169  case 2L: return "ASCII_1";
5170  case 3L: return "ASCII_2";
5171  case 4L: return "ASCII_3";
5172  default: return "";
5173  }
5174  }
5175 
5176  std::string ArrowStylePreset(int64_t i, const std::string &strip) {
5177  std::string s = ArrowStylePreset(i);
5178  if (s.empty())
5179  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset)" + boost::lexical_cast<std::string>(i);
5180  if (boost::starts_with(s, strip))
5181  s = s.substr(strip.size());
5182  return s;
5183  }
5184 
5185  const std::vector<int64_t>& ArrowStylePreset() {
5186  static const int64_t values[] = {
5187  0L,
5188  1L,
5189  2L,
5190  3L,
5191  4L
5192  };
5193  static const std::vector<int64_t> retval(values, values + 5);
5194  return retval;
5195  }
5196 
5197 }}}}}
5198 
5199 namespace Rose {
5200  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset(int64_t i, const char *strip, bool canonic) {
5202  if (retval.empty()) {
5203  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset)" + boost::lexical_cast<std::string>(i);
5204  } else {
5205  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5206  retval = retval.substr(strlen(strip));
5207  if (canonic)
5208  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowStylePreset::" + retval;
5209  }
5210  return retval;
5211  }
5212 
5213  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset() {
5215  }
5216 }
5217 
5218 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5219 // /src/backend/asmUnparser/BinaryEdgeArrows.h line 68
5220 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
5221  const char* ArrowSide(int64_t i) {
5222  switch (i) {
5223  case 0L: return "LEFT";
5224  case 1L: return "RIGHT";
5225  default: return "";
5226  }
5227  }
5228 
5229  std::string ArrowSide(int64_t i, const std::string &strip) {
5230  std::string s = ArrowSide(i);
5231  if (s.empty())
5232  s = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide)" + boost::lexical_cast<std::string>(i);
5233  if (boost::starts_with(s, strip))
5234  s = s.substr(strip.size());
5235  return s;
5236  }
5237 
5238  const std::vector<int64_t>& ArrowSide() {
5239  static const int64_t values[] = {
5240  0L,
5241  1L
5242  };
5243  static const std::vector<int64_t> retval(values, values + 2);
5244  return retval;
5245  }
5246 
5247 }}}}}
5248 
5249 namespace Rose {
5250  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide(int64_t i, const char *strip, bool canonic) {
5252  if (retval.empty()) {
5253  retval = "(Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide)" + boost::lexical_cast<std::string>(i);
5254  } else {
5255  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5256  retval = retval.substr(strlen(strip));
5257  if (canonic)
5258  retval = "Rose::BinaryAnalysis::Unparser::EdgeArrows::ArrowSide::" + retval;
5259  }
5260  return retval;
5261  }
5262 
5263  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide() {
5265  }
5266 }
5267 
5268 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5269 // /src/backend/asmUnparser/BinarySerialIo.h line 119
5270 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
5271  const char* Format(int64_t i) {
5272  switch (i) {
5273  case 0L: return "BINARY";
5274  case 1L: return "TEXT";
5275  case 2L: return "XML";
5276  default: return "";
5277  }
5278  }
5279 
5280  std::string Format(int64_t i, const std::string &strip) {
5281  std::string s = Format(i);
5282  if (s.empty())
5283  s = "(Rose::BinaryAnalysis::SerialIo::Format)" + boost::lexical_cast<std::string>(i);
5284  if (boost::starts_with(s, strip))
5285  s = s.substr(strip.size());
5286  return s;
5287  }
5288 
5289  const std::vector<int64_t>& Format() {
5290  static const int64_t values[] = {
5291  0L,
5292  1L,
5293  2L
5294  };
5295  static const std::vector<int64_t> retval(values, values + 3);
5296  return retval;
5297  }
5298 
5299 }}}}
5300 
5301 namespace Rose {
5302  std::string stringifyBinaryAnalysisSerialIoFormat(int64_t i, const char *strip, bool canonic) {
5303  std::string retval = stringify::Rose::BinaryAnalysis::SerialIo::Format(i);
5304  if (retval.empty()) {
5305  retval = "(Rose::BinaryAnalysis::SerialIo::Format)" + boost::lexical_cast<std::string>(i);
5306  } else {
5307  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5308  retval = retval.substr(strlen(strip));
5309  if (canonic)
5310  retval = "Rose::BinaryAnalysis::SerialIo::Format::" + retval;
5311  }
5312  return retval;
5313  }
5314 
5315  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoFormat() {
5317  }
5318 }
5319 
5320 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5321 // /src/backend/asmUnparser/BinarySerialIo.h line 130
5322 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
5323  const char* Savable(int64_t i) {
5324  switch (i) {
5325  case 0L: return "NO_OBJECT";
5326  case 1L: return "PARTITIONER";
5327  case 2L: return "AST";
5328  case 65534L: return "END_OF_DATA";
5329  case 65535L: return "ERROR";
5330  case 65536L: return "USER_DEFINED";
5331  case 4294967295L: return "USER_DEFINED_LAST";
5332  default: return "";
5333  }
5334  }
5335 
5336  std::string Savable(int64_t i, const std::string &strip) {
5337  std::string s = Savable(i);
5338  if (s.empty())
5339  s = "(Rose::BinaryAnalysis::SerialIo::Savable)" + boost::lexical_cast<std::string>(i);
5340  if (boost::starts_with(s, strip))
5341  s = s.substr(strip.size());
5342  return s;
5343  }
5344 
5345  const std::vector<int64_t>& Savable() {
5346  static const int64_t values[] = {
5347  0L,
5348  1L,
5349  2L,
5350  65534L,
5351  65535L,
5352  65536L,
5353  4294967295L
5354  };
5355  static const std::vector<int64_t> retval(values, values + 7);
5356  return retval;
5357  }
5358 
5359 }}}}
5360 
5361 namespace Rose {
5362  std::string stringifyBinaryAnalysisSerialIoSavable(int64_t i, const char *strip, bool canonic) {
5364  if (retval.empty()) {
5365  retval = "(Rose::BinaryAnalysis::SerialIo::Savable)" + boost::lexical_cast<std::string>(i);
5366  } else {
5367  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5368  retval = retval.substr(strlen(strip));
5369  if (canonic)
5370  retval = "Rose::BinaryAnalysis::SerialIo::Savable::" + retval;
5371  }
5372  return retval;
5373  }
5374 
5375  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoSavable() {
5377  }
5378 }
5379 
5380 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5381 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 19
5382 namespace stringify {
5383  const char* AssociativitySpecifier(int64_t i) {
5384  switch (i) {
5385  case 0L: return "e_assoc_none";
5386  case 1L: return "e_assoc_right";
5387  case 2L: return "e_assoc_left";
5388  case 3L: return "e_assoc_last";
5389  default: return "";
5390  }
5391  }
5392 
5393  std::string AssociativitySpecifier(int64_t i, const std::string &strip) {
5394  std::string s = AssociativitySpecifier(i);
5395  if (s.empty())
5396  s = "(AssociativitySpecifier)" + boost::lexical_cast<std::string>(i);
5397  if (boost::starts_with(s, strip))
5398  s = s.substr(strip.size());
5399  return s;
5400  }
5401 
5402  const std::vector<int64_t>& AssociativitySpecifier() {
5403  static const int64_t values[] = {
5404  0L,
5405  1L,
5406  2L,
5407  3L
5408  };
5409  static const std::vector<int64_t> retval(values, values + 4);
5410  return retval;
5411  }
5412 
5413 }
5414 
5415 namespace Rose {
5416  std::string stringifyAssociativitySpecifier(int64_t i, const char *strip, bool canonic) {
5417  std::string retval = stringify::AssociativitySpecifier(i);
5418  if (retval.empty()) {
5419  retval = "(AssociativitySpecifier)" + boost::lexical_cast<std::string>(i);
5420  } else {
5421  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5422  retval = retval.substr(strlen(strip));
5423  if (canonic)
5424  retval = "AssociativitySpecifier::" + retval;
5425  }
5426  return retval;
5427  }
5428 
5429  const std::vector<int64_t>& stringifyAssociativitySpecifier() {
5431  }
5432 }
5433 
5434 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5435 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 46
5436 namespace stringify { namespace UnparseLanguageIndependentConstructs {
5437  const char* token_sequence_position_enum_type(int64_t i) {
5438  switch (i) {
5439  case 0L: return "e_leading_whitespace_start";
5440  case 1L: return "e_leading_whitespace_end";
5441  case 2L: return "e_token_subsequence_start";
5442  case 3L: return "e_token_subsequence_end";
5443  case 4L: return "e_trailing_whitespace_start";
5444  case 5L: return "e_trailing_whitespace_end";
5445  case 6L: return "e_else_whitespace_start";
5446  case 7L: return "e_else_whitespace_end";
5447  default: return "";
5448  }
5449  }
5450 
5451  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
5452  std::string s = token_sequence_position_enum_type(i);
5453  if (s.empty())
5454  s = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5455  if (boost::starts_with(s, strip))
5456  s = s.substr(strip.size());
5457  return s;
5458  }
5459 
5460  const std::vector<int64_t>& token_sequence_position_enum_type() {
5461  static const int64_t values[] = {
5462  0L,
5463  1L,
5464  2L,
5465  3L,
5466  4L,
5467  5L,
5468  6L,
5469  7L
5470  };
5471  static const std::vector<int64_t> retval(values, values + 8);
5472  return retval;
5473  }
5474 
5475 }}
5476 
5477 namespace Rose {
5478  std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
5480  if (retval.empty()) {
5481  retval = "(UnparseLanguageIndependentConstructs::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5482  } else {
5483  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5484  retval = retval.substr(strlen(strip));
5485  if (canonic)
5486  retval = "UnparseLanguageIndependentConstructs::token_sequence_position_enum_type::" + retval;
5487  }
5488  return retval;
5489  }
5490 
5491  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type() {
5493  }
5494 }
5495 
5496 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5497 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 74
5498 namespace stringify { namespace UnparseLanguageIndependentConstructs {
5499  const char* unparsed_as_enum_type(int64_t i) {
5500  switch (i) {
5501  case 0L: return "e_unparsed_as_error";
5502  case 1L: return "e_unparsed_as_AST";
5503  case 2L: return "e_unparsed_as_partial_token_sequence";
5504  case 3L: return "e_unparsed_as_token_stream";
5505  case 4L: return "e_unparsed_as_last";
5506  default: return "";
5507  }
5508  }
5509 
5510  std::string unparsed_as_enum_type(int64_t i, const std::string &strip) {
5511  std::string s = unparsed_as_enum_type(i);
5512  if (s.empty())
5513  s = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_type)" + boost::lexical_cast<std::string>(i);
5514  if (boost::starts_with(s, strip))
5515  s = s.substr(strip.size());
5516  return s;
5517  }
5518 
5519  const std::vector<int64_t>& unparsed_as_enum_type() {
5520  static const int64_t values[] = {
5521  0L,
5522  1L,
5523  2L,
5524  3L,
5525  4L
5526  };
5527  static const std::vector<int64_t> retval(values, values + 5);
5528  return retval;
5529  }
5530 
5531 }}
5532 
5533 namespace Rose {
5534  std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t i, const char *strip, bool canonic) {
5536  if (retval.empty()) {
5537  retval = "(UnparseLanguageIndependentConstructs::unparsed_as_enum_type)" + boost::lexical_cast<std::string>(i);
5538  } else {
5539  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5540  retval = retval.substr(strlen(strip));
5541  if (canonic)
5542  retval = "UnparseLanguageIndependentConstructs::unparsed_as_enum_type::" + retval;
5543  }
5544  return retval;
5545  }
5546 
5547  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type() {
5549  }
5550 }
5551 
5552 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5553 // /src/backend/unparser/formatSupport/unparse_format.h line 51
5554 namespace stringify {
5555  const char* Format_Opt(int64_t i) {
5556  switch (i) {
5557  case 0L: return "FORMAT_BEFORE_DIRECTIVE";
5558  case 1L: return "FORMAT_AFTER_DIRECTIVE";
5559  case 2L: return "FORMAT_BEFORE_STMT";
5560  case 3L: return "FORMAT_AFTER_STMT";
5561  case 4L: return "FORMAT_BEFORE_BASIC_BLOCK1";
5562  case 5L: return "FORMAT_AFTER_BASIC_BLOCK1";
5563  case 6L: return "FORMAT_BEFORE_BASIC_BLOCK2";
5564  case 7L: return "FORMAT_AFTER_BASIC_BLOCK2";
5565  case 8L: return "FORMAT_BEFORE_NESTED_STATEMENT";
5566  case 9L: return "FORMAT_AFTER_NESTED_STATEMENT";
5567  default: return "";
5568  }
5569  }
5570 
5571  std::string Format_Opt(int64_t i, const std::string &strip) {
5572  std::string s = Format_Opt(i);
5573  if (s.empty())
5574  s = "(Format_Opt)" + boost::lexical_cast<std::string>(i);
5575  if (boost::starts_with(s, strip))
5576  s = s.substr(strip.size());
5577  return s;
5578  }
5579 
5580  const std::vector<int64_t>& Format_Opt() {
5581  static const int64_t values[] = {
5582  0L,
5583  1L,
5584  2L,
5585  3L,
5586  4L,
5587  5L,
5588  6L,
5589  7L,
5590  8L,
5591  9L
5592  };
5593  static const std::vector<int64_t> retval(values, values + 10);
5594  return retval;
5595  }
5596 
5597 }
5598 
5599 namespace Rose {
5600  std::string stringifyFormat_Opt(int64_t i, const char *strip, bool canonic) {
5601  std::string retval = stringify::Format_Opt(i);
5602  if (retval.empty()) {
5603  retval = "(Format_Opt)" + boost::lexical_cast<std::string>(i);
5604  } else {
5605  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5606  retval = retval.substr(strlen(strip));
5607  if (canonic)
5608  retval = "Format_Opt::" + retval;
5609  }
5610  return retval;
5611  }
5612 
5613  const std::vector<int64_t>& stringifyFormat_Opt() {
5614  return stringify::Format_Opt();
5615  }
5616 }
5617 
5618 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5619 // /src/backend/unparser/astUnparseAttribute.h line 33
5620 namespace stringify { namespace AstUnparseAttribute {
5621  const char* RelativePositionType(int64_t i) {
5622  switch (i) {
5623  case 0L: return "e_defaultValue";
5624  case 1L: return "e_undef";
5625  case 2L: return "e_before";
5626  case 3L: return "e_after";
5627  case 4L: return "e_inside";
5628  case 5L: return "e_replace";
5629  case 6L: return "e_before_syntax";
5630  case 7L: return "e_after_syntax";
5631  default: return "";
5632  }
5633  }
5634 
5635  std::string RelativePositionType(int64_t i, const std::string &strip) {
5636  std::string s = RelativePositionType(i);
5637  if (s.empty())
5638  s = "(AstUnparseAttribute::RelativePositionType)" + boost::lexical_cast<std::string>(i);
5639  if (boost::starts_with(s, strip))
5640  s = s.substr(strip.size());
5641  return s;
5642  }
5643 
5644  const std::vector<int64_t>& RelativePositionType() {
5645  static const int64_t values[] = {
5646  0L,
5647  1L,
5648  2L,
5649  3L,
5650  4L,
5651  5L,
5652  6L,
5653  7L
5654  };
5655  static const std::vector<int64_t> retval(values, values + 8);
5656  return retval;
5657  }
5658 
5659 }}
5660 
5661 namespace Rose {
5662  std::string stringifyAstUnparseAttributeRelativePositionType(int64_t i, const char *strip, bool canonic) {
5664  if (retval.empty()) {
5665  retval = "(AstUnparseAttribute::RelativePositionType)" + boost::lexical_cast<std::string>(i);
5666  } else {
5667  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5668  retval = retval.substr(strlen(strip));
5669  if (canonic)
5670  retval = "AstUnparseAttribute::RelativePositionType::" + retval;
5671  }
5672  return retval;
5673  }
5674 
5675  const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType() {
5677  }
5678 }
5679 
5680 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5681 // /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 531
5682 namespace stringify { namespace Unparse_ExprStmt {
5683  const char* token_sequence_position_enum_type(int64_t i) {
5684  switch (i) {
5685  case 0L: return "e_leading_whitespace_start";
5686  case 1L: return "e_leading_whitespace_end";
5687  case 2L: return "e_token_subsequence_start";
5688  case 3L: return "e_token_subsequence_end";
5689  case 4L: return "e_trailing_whitespace_start";
5690  case 5L: return "e_trailing_whitespace_end";
5691  default: return "";
5692  }
5693  }
5694 
5695  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
5696  std::string s = token_sequence_position_enum_type(i);
5697  if (s.empty())
5698  s = "(Unparse_ExprStmt::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5699  if (boost::starts_with(s, strip))
5700  s = s.substr(strip.size());
5701  return s;
5702  }
5703 
5704  const std::vector<int64_t>& token_sequence_position_enum_type() {
5705  static const int64_t values[] = {
5706  0L,
5707  1L,
5708  2L,
5709  3L,
5710  4L,
5711  5L
5712  };
5713  static const std::vector<int64_t> retval(values, values + 6);
5714  return retval;
5715  }
5716 
5717 }}
5718 
5719 namespace Rose {
5720  std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
5722  if (retval.empty()) {
5723  retval = "(Unparse_ExprStmt::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5724  } else {
5725  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5726  retval = retval.substr(strlen(strip));
5727  if (canonic)
5728  retval = "Unparse_ExprStmt::token_sequence_position_enum_type::" + retval;
5729  }
5730  return retval;
5731  }
5732 
5733  const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type() {
5735  }
5736 }
5737 
5738 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5739 // /src/backend/unparser/unparser.h line 205
5740 namespace stringify { namespace Unparser {
5741  const char* token_sequence_position_enum_type(int64_t i) {
5742  switch (i) {
5743  case 0L: return "e_leading_whitespace_start";
5744  case 1L: return "e_leading_whitespace_end";
5745  case 2L: return "e_token_subsequence_start";
5746  case 3L: return "e_token_subsequence_end";
5747  case 4L: return "e_trailing_whitespace_start";
5748  case 5L: return "e_trailing_whitespace_end";
5749  default: return "";
5750  }
5751  }
5752 
5753  std::string token_sequence_position_enum_type(int64_t i, const std::string &strip) {
5754  std::string s = token_sequence_position_enum_type(i);
5755  if (s.empty())
5756  s = "(Unparser::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5757  if (boost::starts_with(s, strip))
5758  s = s.substr(strip.size());
5759  return s;
5760  }
5761 
5762  const std::vector<int64_t>& token_sequence_position_enum_type() {
5763  static const int64_t values[] = {
5764  0L,
5765  1L,
5766  2L,
5767  3L,
5768  4L,
5769  5L
5770  };
5771  static const std::vector<int64_t> retval(values, values + 6);
5772  return retval;
5773  }
5774 
5775 }}
5776 
5777 namespace Rose {
5778  std::string stringifyUnparser_token_sequence_position_enum_type(int64_t i, const char *strip, bool canonic) {
5780  if (retval.empty()) {
5781  retval = "(Unparser::token_sequence_position_enum_type)" + boost::lexical_cast<std::string>(i);
5782  } else {
5783  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5784  retval = retval.substr(strlen(strip));
5785  if (canonic)
5786  retval = "Unparser::token_sequence_position_enum_type::" + retval;
5787  }
5788  return retval;
5789  }
5790 
5791  const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type() {
5793  }
5794 }
5795 
5796 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5797 // /src/frontend/BinaryFormats/MemoryMap.h line 126
5798 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
5799  const char* Boolean(int64_t i) {
5800  switch (i) {
5801  case 0L: return "NO";
5802  case 1L: return "YES";
5803  default: return "";
5804  }
5805  }
5806 
5807  std::string Boolean(int64_t i, const std::string &strip) {
5808  std::string s = Boolean(i);
5809  if (s.empty())
5810  s = "(Rose::BinaryAnalysis::MemoryMap::Attach::Boolean)" + boost::lexical_cast<std::string>(i);
5811  if (boost::starts_with(s, strip))
5812  s = s.substr(strip.size());
5813  return s;
5814  }
5815 
5816  const std::vector<int64_t>& Boolean() {
5817  static const int64_t values[] = {
5818  0L,
5819  1L
5820  };
5821  static const std::vector<int64_t> retval(values, values + 2);
5822  return retval;
5823  }
5824 
5825 }}}}}
5826 
5827 namespace Rose {
5828  std::string stringifyBinaryAnalysisMemoryMapAttachBoolean(int64_t i, const char *strip, bool canonic) {
5830  if (retval.empty()) {
5831  retval = "(Rose::BinaryAnalysis::MemoryMap::Attach::Boolean)" + boost::lexical_cast<std::string>(i);
5832  } else {
5833  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5834  retval = retval.substr(strlen(strip));
5835  if (canonic)
5836  retval = "Rose::BinaryAnalysis::MemoryMap::Attach::Boolean::" + retval;
5837  }
5838  return retval;
5839  }
5840 
5841  const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapAttachBoolean() {
5843  }
5844 }
5845 
5846 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5847 // /src/frontend/BinaryFormats/MemoryMap.h line 282
5848 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
5849  const char* InsertFileMapMode(int64_t i) {
5850  switch (i) {
5851  case 0L: return "MAP_PRIVATE";
5852  case 1L: return "MAP_READWRITE";
5853  case 2L: return "MAP_RDONLY";
5854  default: return "";
5855  }
5856  }
5857 
5858  std::string InsertFileMapMode(int64_t i, const std::string &strip) {
5859  std::string s = InsertFileMapMode(i);
5860  if (s.empty())
5861  s = "(Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode)" + boost::lexical_cast<std::string>(i);
5862  if (boost::starts_with(s, strip))
5863  s = s.substr(strip.size());
5864  return s;
5865  }
5866 
5867  const std::vector<int64_t>& InsertFileMapMode() {
5868  static const int64_t values[] = {
5869  0L,
5870  1L,
5871  2L
5872  };
5873  static const std::vector<int64_t> retval(values, values + 3);
5874  return retval;
5875  }
5876 
5877 }}}}
5878 
5879 namespace Rose {
5880  std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(int64_t i, const char *strip, bool canonic) {
5882  if (retval.empty()) {
5883  retval = "(Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode)" + boost::lexical_cast<std::string>(i);
5884  } else {
5885  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5886  retval = retval.substr(strlen(strip));
5887  if (canonic)
5888  retval = "Rose::BinaryAnalysis::MemoryMap::InsertFileMapMode::" + retval;
5889  }
5890  return retval;
5891  }
5892 
5893  const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapInsertFileMapMode() {
5895  }
5896 }
5897 
5898 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5899 // /src/frontend/BinaryFormats/SRecord.h line 28
5900 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
5901  const char* Syntax(int64_t i) {
5902  switch (i) {
5903  case 0L: return "SREC_MOTOROLA";
5904  case 1L: return "SREC_INTEL";
5905  case 2L: return "SREC_UNKNOWN_SYNTAX";
5906  default: return "";
5907  }
5908  }
5909 
5910  std::string Syntax(int64_t i, const std::string &strip) {
5911  std::string s = Syntax(i);
5912  if (s.empty())
5913  s = "(Rose::BinaryAnalysis::SRecord::Syntax)" + boost::lexical_cast<std::string>(i);
5914  if (boost::starts_with(s, strip))
5915  s = s.substr(strip.size());
5916  return s;
5917  }
5918 
5919  const std::vector<int64_t>& Syntax() {
5920  static const int64_t values[] = {
5921  0L,
5922  1L,
5923  2L
5924  };
5925  static const std::vector<int64_t> retval(values, values + 3);
5926  return retval;
5927  }
5928 
5929 }}}}
5930 
5931 namespace Rose {
5932  std::string stringifyBinaryAnalysisSRecordSyntax(int64_t i, const char *strip, bool canonic) {
5933  std::string retval = stringify::Rose::BinaryAnalysis::SRecord::Syntax(i);
5934  if (retval.empty()) {
5935  retval = "(Rose::BinaryAnalysis::SRecord::Syntax)" + boost::lexical_cast<std::string>(i);
5936  } else {
5937  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5938  retval = retval.substr(strlen(strip));
5939  if (canonic)
5940  retval = "Rose::BinaryAnalysis::SRecord::Syntax::" + retval;
5941  }
5942  return retval;
5943  }
5944 
5945  const std::vector<int64_t>& stringifyBinaryAnalysisSRecordSyntax() {
5947  }
5948 }
5949 
5950 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5951 // /src/frontend/BinaryFormats/SRecord.h line 35
5952 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
5953  const char* Type(int64_t i) {
5954  switch (i) {
5955  case 0L: return "SREC_M_HEADER";
5956  case 1L: return "SREC_M_DATA16";
5957  case 2L: return "SREC_M_DATA24";
5958  case 3L: return "SREC_M_DATA32";
5959  case 4L: return "SREC_M_RESERVED";
5960  case 5L: return "SREC_M_COUNT16";
5961  case 6L: return "SREC_M_COUNT24";
5962  case 7L: return "SREC_M_START32";
5963  case 8L: return "SREC_M_START24";
5964  case 9L: return "SREC_M_START16";
5965  case 10L: return "SREC_I_DATA";
5966  case 11L: return "SREC_I_END";
5967  case 12L: return "SREC_I_EXTENDED_SA";
5968  case 13L: return "SREC_I_START_SA";
5969  case 14L: return "SREC_I_EXTENDED_LA";
5970  case 15L: return "SREC_I_START_LA";
5971  case 16L: return "SREC_UNKNOWN_TYPE";
5972  default: return "";
5973  }
5974  }
5975 
5976  std::string Type(int64_t i, const std::string &strip) {
5977  std::string s = Type(i);
5978  if (s.empty())
5979  s = "(Rose::BinaryAnalysis::SRecord::Type)" + boost::lexical_cast<std::string>(i);
5980  if (boost::starts_with(s, strip))
5981  s = s.substr(strip.size());
5982  return s;
5983  }
5984 
5985  const std::vector<int64_t>& Type() {
5986  static const int64_t values[] = {
5987  0L,
5988  1L,
5989  2L,
5990  3L,
5991  4L,
5992  5L,
5993  6L,
5994  7L,
5995  8L,
5996  9L,
5997  10L,
5998  11L,
5999  12L,
6000  13L,
6001  14L,
6002  15L,
6003  16L
6004  };
6005  static const std::vector<int64_t> retval(values, values + 17);
6006  return retval;
6007  }
6008 
6009 }}}}
6010 
6011 namespace Rose {
6012  std::string stringifyBinaryAnalysisSRecordType(int64_t i, const char *strip, bool canonic) {
6013  std::string retval = stringify::Rose::BinaryAnalysis::SRecord::Type(i);
6014  if (retval.empty()) {
6015  retval = "(Rose::BinaryAnalysis::SRecord::Type)" + boost::lexical_cast<std::string>(i);
6016  } else {
6017  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
6018  retval = retval.substr(strlen(strip));
6019  if (canonic)
6020  retval = "Rose::BinaryAnalysis::SRecord::Type::" + retval;
6021  }
6022  return retval;
6023  }
6024 
6025  const std::vector<int64_t>& stringifyBinaryAnalysisSRecordType() {
6027  }
6028 }
6029 
6030 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6031 // /src/frontend/BinaryFormats/ByteOrder.h line 7
6032 namespace stringify { namespace ByteOrder {
6033  const char* Endianness(int64_t i) {
6034  switch (i) {
6035  case 0L: return "ORDER_UNSPECIFIED";
6036  case 1L: return "ORDER_LSB";
6037  case 2L: return "ORDER_MSB";
6038  default: return "";
6039  }
6040  }
6041 
6042  std::string Endianness(int64_t i, const std::string &strip) {
6043  std::string s = Endianness(i);
6044  if (s.empty())
6045  s = "(ByteOrder::Endianness)" + boost::lexical_cast<std::string>(i);
6046  if (boost::starts_with(s, strip))
6047  s = s.substr(strip.size());
6048  return s;
6049  }
6050 
6051  const std::vector<int64_t>& Endianness() {
6052  static const int64_t values[] = {
6053  0L,
6054  1L,
6055  2L
6056  };
6057  static const std::vector<int64_t> retval(values, values + 3);
6058  return retval;
6059  }
6060 
6061 }}
6062 
6063 namespace Rose {
6064  std::string stringifyByteOrderEndianness(int64_t i, const char *strip, bool canonic) {
6065  std::string retval = stringify::ByteOrder::Endianness(i);
6066  if (retval.empty()) {
6067  retval = "(ByteOrder::Endianness)" + boost::lexical_cast<std::string>(i);
6068  } else {
6069  if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
6070  retval = retval.substr(strlen(strip));
6071  if (canonic)
6072  retval = "ByteOrder::Endianness::" + retval;
6073  }
6074  return retval;
6075  }
6076 
6077  const std::vector<int64_t>& stringifyByteOrderEndianness() {
6079  }
6080 }
6081 
6082 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6083 // /src/frontend/Experimental_General_Language_Support/general_language_translation.h line 11
6084 namespace stringify { namespace General_Language_Translation {
6085  const char* ExpressionKind(int64_t i) {
6086  switch (i) {
6087  case 0L: return "e_unknown";
6088  case 1L: return "e_access_modifier_public";
6089  case 2L: return "e_access_modifier_private";
6090  case 3L: return "e_storage_modifier_contiguous";
6091  case 4L: return "e_storage_modifier_external";
6092  case 5L: return "e_storage_modifier_static";
6093  case 6L: return "e_storage_modifier_location";
6094  case 7L: return "e_storage_modifier_jovial_def";
6095  case 8L: return "e_storage_modifier_jovial_ref";
6096  case 9L: return "e_type_modifier_list";
6097  case 10L: return "e_type_modifier_allocatable";
6098  case 11L: return "e_type_modifier_asynchronous";
6099  case 12L: return "e_type_modifier_const";
6100  case 13L: return "e_type_modifier_intent_in";
6101  case 14L: return "e_type_modifier_intent_out";
6102  case 15L: return "e_type_modifier_intent_inout";
6103  case 16L: return "e_type_modifier_intrinsic";
6104  case 17L: return "e_type_modifier_optional";
6105  case 18L: return "e_type_modifier_pointer";
6106  case 19L: return "e_type_modifier_protected";
6107  case 20L: return "e_type_modifier_round";
6108  case 21L: return "e_type_modifier_save";
6109  case 22L: return "e_type_modifier_target";
6110  case 23L: return "e_type_modifier_truncate";
6111  case 24L: return "e_type_modifier_value";
6112  case 25L: return "e_type_modifier_reference";
6113  case 26L: return "e_type_modifier_result";
6114  case 27L: return "e_type_modifier_volatile";
6115  case 28L: return "e_type_modifier_z";
6116  case 29L: return "e_function_modifier_list";
6117  case 30L: return "e_function_modifier_none";
6118  case 31L: return "e_function_modifier_elemental";
6119  case 32L: return "e_function_modifier_impure";
6120  case 33L: return "e_function_modifier_module";
6121  case 34L: return "e_function_modifier_pure";
6122  case 35L: return "e_function_modifier_recursive";
6123  case 36L: return "e_function_modifier_reentrant";
6124  case 37L: return "e_struct_modifier_list";
6125  case 38L: return "e_struct_item_modifier_list";
6126  case 39L: return "e_operator_assign";
6127  case 40L: return "e_operator_exponentiate";
6128  case 41L: return "e_operator_concatenate";
6129  case 42L: return "e_operator_add";
6130  case 43L: return "e_operator_subtract";
6131  case 44L: return "e_operator_mod";
6132  case 45L: return "e_operator_multiply";
6133  case 46L: return "e_operator_divide";
6134  case 47L: return "e_operator_and";
6135  case 48L: return "e_operator_or";
6136  case 49L: return "e_operator_xor";
6137  case 50L: return "e_operator_equiv";
6138  case 51L: return "e_operator_less_than";
6139  case 52L: return "e_operator_greater_than";
6140  case 53L: return "e_operator_less_than_or_equal";
6141  case 54L: return "e_operator_greater_than_or_equal";
6142  case 55L: return "e_operator_equality";
6143  case 56L: return "e_operator_not_equal";
6144  case 57L: return "e_operator_unary_plus";
6145  case 58L: return "e_operator_unary_minus";
6146  case 59L: return "e_operator_unary_not";
6147  case 60L: return "e_operator_unity";
6148  case 61L: return "e_literalExpression";
6149  case 62L: return "e_function_reference";
6150  case 63L: return "e_procedure_call";
6151  case 64L: return "e_argument_list";
6152  case 65L: return "e_argument_keyword";
6153  case 66L: return "e_variable_reference";
6154