ROSE  0.11.131.0
stringify.h
1 // DO NOT EDIT -- This file is automatically generated.
2 
3 #ifndef ROSE_STRINGIFY_H
4 #define ROSE_STRINGIFY_H
5 #include <boost/algorithm/string/predicate.hpp>
6 #include <boost/lexical_cast.hpp>
7 #include <string>
8 #include <vector>
9 
10 namespace Rose {
20 class Stringifier {
21  std::string(*stringifier_)(int64_t, const char*, bool);
22 public:
23  Stringifier(std::string(*stringifier)(int64_t, const char*, bool)): stringifier_(stringifier) {}
24  std::string operator()(int64_t n, const char *strip=NULL, bool canonic=false) {
25  return stringifier_(n, strip, canonic);
26  }
27 };
28 }
29 
30 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
31 // /src/Rose/AST/Defect.h line 19
32 namespace stringify { namespace Rose { namespace AST { namespace Defects {
34  const char* Kind(int64_t);
35 
37  std::string Kind(int64_t, const std::string &strip);
38 
40  const std::vector<int64_t>& Kind();
41 }}}}
42 
43 namespace Rose {
44  std::string stringifyAST_DefectsKind(int64_t n, const char *strip=NULL, bool canonic=false);
45  const std::vector<int64_t>& stringifyAST_DefectsKind();
46 }
47 
48 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
49 // /src/Rose/AST/Defect.h line 97
50 namespace stringify { namespace Rose { namespace AST { namespace Defects {
52  const char* Reason(int64_t);
53 
55  std::string Reason(int64_t, const std::string &strip);
56 
58  const std::vector<int64_t>& Reason();
59 }}}}
60 
61 namespace Rose {
62  std::string stringifyAST_DefectsReason(int64_t n, const char *strip=NULL, bool canonic=false);
63  const std::vector<int64_t>& stringifyAST_DefectsReason();
64 }
65 
66 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
67 // /src/Rose/AST/cmdline.h line 25
68 namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace graphviz_t {
70  const char* Mode(int64_t);
71 
73  std::string Mode(int64_t, const std::string &strip);
74 
76  const std::vector<int64_t>& Mode();
77 }}}}}
78 
79 namespace Rose {
80  std::string stringifyASTcmdline_graphviz_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
81  const std::vector<int64_t>& stringifyASTcmdline_graphviz_tMode();
82 }
83 
84 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
85 // /src/Rose/AST/cmdline.h line 43
86 namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
88  const char* Mode(int64_t);
89 
91  std::string Mode(int64_t, const std::string &strip);
92 
94  const std::vector<int64_t>& Mode();
95 }}}}}
96 
97 namespace Rose {
98  std::string stringifyASTcmdline_checker_tMode(int64_t n, const char *strip=NULL, bool canonic=false);
99  const std::vector<int64_t>& stringifyASTcmdline_checker_tMode();
100 }
101 
102 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
103 // /src/Rose/AST/cmdline.h line 54
104 namespace stringify { namespace Rose { namespace AST { namespace cmdline { namespace checker_t {
106  const char* Effect(int64_t);
107 
109  std::string Effect(int64_t, const std::string &strip);
110 
112  const std::vector<int64_t>& Effect();
113 }}}}}
114 
115 namespace Rose {
116  std::string stringifyASTcmdline_checker_tEffect(int64_t n, const char *strip=NULL, bool canonic=false);
117  const std::vector<int64_t>& stringifyASTcmdline_checker_tEffect();
118 }
119 
120 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
121 // /src/Rose/FormattedTable.h line 22
122 namespace stringify { namespace Rose { namespace FormattedTable {
124  const char* Format(int64_t);
125 
127  std::string Format(int64_t, const std::string &strip);
128 
130  const std::vector<int64_t>& Format();
131 }}}
132 
133 namespace Rose {
134  std::string stringifyFormattedTableFormat(int64_t n, const char *strip=NULL, bool canonic=false);
135  const std::vector<int64_t>& stringifyFormattedTableFormat();
136 }
137 
138 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
139 // /src/Rose/FormattedTable.h line 35
140 namespace stringify { namespace Rose { namespace FormattedTable {
142  const char* Alignment(int64_t);
143 
145  std::string Alignment(int64_t, const std::string &strip);
146 
148  const std::vector<int64_t>& Alignment();
149 }}}
150 
151 namespace Rose {
152  std::string stringifyFormattedTableAlignment(int64_t n, const char *strip=NULL, bool canonic=false);
153  const std::vector<int64_t>& stringifyFormattedTableAlignment();
154 }
155 
156 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
157 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 18
158 namespace stringify { namespace Rose { namespace BinaryAnalysis {
160  const char* CilFamily(int64_t);
161 
163  std::string CilFamily(int64_t, const std::string &strip);
164 
166  const std::vector<int64_t>& CilFamily();
167 }}}
168 
169 namespace Rose {
170  std::string stringifyBinaryAnalysisCilFamily(int64_t n, const char *strip=NULL, bool canonic=false);
171  const std::vector<int64_t>& stringifyBinaryAnalysisCilFamily();
172 }
173 
174 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
175 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 23
176 namespace stringify { namespace Rose { namespace BinaryAnalysis {
178  const char* CilRegisterClass(int64_t);
179 
181  std::string CilRegisterClass(int64_t, const std::string &strip);
182 
184  const std::vector<int64_t>& CilRegisterClass();
185 }}}
186 
187 namespace Rose {
188  std::string stringifyBinaryAnalysisCilRegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
189  const std::vector<int64_t>& stringifyBinaryAnalysisCilRegisterClass();
190 }
191 
192 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
193 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 33
194 namespace stringify { namespace Rose { namespace BinaryAnalysis {
196  const char* CilSpecialPurposeRegister(int64_t);
197 
199  std::string CilSpecialPurposeRegister(int64_t, const std::string &strip);
200 
202  const std::vector<int64_t>& CilSpecialPurposeRegister();
203 }}}
204 
205 namespace Rose {
206  std::string stringifyBinaryAnalysisCilSpecialPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
207  const std::vector<int64_t>& stringifyBinaryAnalysisCilSpecialPurposeRegister();
208 }
209 
210 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
211 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 42
212 namespace stringify { namespace Rose { namespace BinaryAnalysis {
214  const char* CilMacRegister(int64_t);
215 
217  std::string CilMacRegister(int64_t, const std::string &strip);
218 
220  const std::vector<int64_t>& CilMacRegister();
221 }}}
222 
223 namespace Rose {
224  std::string stringifyBinaryAnalysisCilMacRegister(int64_t n, const char *strip=NULL, bool canonic=false);
225  const std::vector<int64_t>& stringifyBinaryAnalysisCilMacRegister();
226 }
227 
228 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
229 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 58
230 namespace stringify { namespace Rose { namespace BinaryAnalysis {
232  const char* CilEmacRegister(int64_t);
233 
235  std::string CilEmacRegister(int64_t, const std::string &strip);
236 
238  const std::vector<int64_t>& CilEmacRegister();
239 }}}
240 
241 namespace Rose {
242  std::string stringifyBinaryAnalysisCilEmacRegister(int64_t n, const char *strip=NULL, bool canonic=false);
243  const std::vector<int64_t>& stringifyBinaryAnalysisCilEmacRegister();
244 }
245 
246 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
247 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 68
248 namespace stringify { namespace Rose { namespace BinaryAnalysis {
250  const char* CilSupervisorRegister(int64_t);
251 
253  std::string CilSupervisorRegister(int64_t, const std::string &strip);
254 
256  const std::vector<int64_t>& CilSupervisorRegister();
257 }}}
258 
259 namespace Rose {
260  std::string stringifyBinaryAnalysisCilSupervisorRegister(int64_t n, const char *strip=NULL, bool canonic=false);
261  const std::vector<int64_t>& stringifyBinaryAnalysisCilSupervisorRegister();
262 }
263 
264 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
265 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 155
266 namespace stringify { namespace Rose { namespace BinaryAnalysis {
268  const char* CilEffectiveAddressMode(int64_t);
269 
271  std::string CilEffectiveAddressMode(int64_t, const std::string &strip);
272 
274  const std::vector<int64_t>& CilEffectiveAddressMode();
275 }}}
276 
277 namespace Rose {
278  std::string stringifyBinaryAnalysisCilEffectiveAddressMode(int64_t n, const char *strip=NULL, bool canonic=false);
279  const std::vector<int64_t>& stringifyBinaryAnalysisCilEffectiveAddressMode();
280 }
281 
282 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
283 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 209
284 namespace stringify { namespace Rose { namespace BinaryAnalysis {
286  const char* CilDataFormat(int64_t);
287 
289  std::string CilDataFormat(int64_t, const std::string &strip);
290 
292  const std::vector<int64_t>& CilDataFormat();
293 }}}
294 
295 namespace Rose {
296  std::string stringifyBinaryAnalysisCilDataFormat(int64_t n, const char *strip=NULL, bool canonic=false);
297  const std::vector<int64_t>& stringifyBinaryAnalysisCilDataFormat();
298 }
299 
300 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
301 // /src/Rose/BinaryAnalysis/InstructionEnumsCil.h line 221
302 namespace stringify { namespace Rose { namespace BinaryAnalysis {
304  const char* CilInstructionKind(int64_t);
305 
307  std::string CilInstructionKind(int64_t, const std::string &strip);
308 
310  const std::vector<int64_t>& CilInstructionKind();
311 }}}
312 
313 namespace Rose {
314  std::string stringifyBinaryAnalysisCilInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
315  const std::vector<int64_t>& stringifyBinaryAnalysisCilInstructionKind();
316 }
317 
318 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
319 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 37
320 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
322  const char* SearchMode(int64_t);
323 
325  std::string SearchMode(int64_t, const std::string &strip);
326 
328  const std::vector<int64_t>& SearchMode();
329 }}}}
330 
331 namespace Rose {
332  std::string stringifyBinaryAnalysisFeasiblePathSearchMode(int64_t n, const char *strip=NULL, bool canonic=false);
333  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSearchMode();
334 }
335 
336 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
337 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 44
338 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
340  const char* SemanticMemoryParadigm(int64_t);
341 
343  std::string SemanticMemoryParadigm(int64_t, const std::string &strip);
344 
346  const std::vector<int64_t>& SemanticMemoryParadigm();
347 }}}}
348 
349 namespace Rose {
350  std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(int64_t n, const char *strip=NULL, bool canonic=false);
351  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm();
352 }
353 
354 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
355 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 50
356 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
358  const char* EdgeVisitOrder(int64_t);
359 
361  std::string EdgeVisitOrder(int64_t, const std::string &strip);
362 
364  const std::vector<int64_t>& EdgeVisitOrder();
365 }}}}
366 
367 namespace Rose {
368  std::string stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder(int64_t n, const char *strip=NULL, bool canonic=false);
369  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder();
370 }
371 
372 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
373 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 57
374 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
376  const char* IoMode(int64_t);
377 
379  std::string IoMode(int64_t, const std::string &strip);
380 
382  const std::vector<int64_t>& IoMode();
383 }}}}
384 
385 namespace Rose {
386  std::string stringifyBinaryAnalysisFeasiblePathIoMode(int64_t n, const char *strip=NULL, bool canonic=false);
387  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathIoMode();
388 }
389 
390 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
391 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 60
392 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath {
394  const char* MayOrMust(int64_t);
395 
397  std::string MayOrMust(int64_t, const std::string &strip);
398 
400  const std::vector<int64_t>& MayOrMust();
401 }}}}
402 
403 namespace Rose {
404  std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(int64_t n, const char *strip=NULL, bool canonic=false);
405  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathMayOrMust();
406 }
407 
408 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
409 // /src/Rose/BinaryAnalysis/FeasiblePath.h line 180
410 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FeasiblePath { namespace PathProcessor {
412  const char* Action(int64_t);
413 
415  std::string Action(int64_t, const std::string &strip);
416 
418  const std::vector<int64_t>& Action();
419 }}}}}
420 
421 namespace Rose {
422  std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(int64_t n, const char *strip=NULL, bool canonic=false);
423  const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathPathProcessorAction();
424 }
425 
426 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
427 // /src/Rose/BinaryAnalysis/HotPatch.h line 31
428 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
430  const char* Type(int64_t);
431 
433  std::string Type(int64_t, const std::string &strip);
434 
436  const std::vector<int64_t>& Type();
437 }}}}}
438 
439 namespace Rose {
440  std::string stringifyBinaryAnalysisHotPatchRecordType(int64_t n, const char *strip=NULL, bool canonic=false);
441  const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordType();
442 }
443 
444 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
445 // /src/Rose/BinaryAnalysis/HotPatch.h line 37
446 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace HotPatch { namespace Record {
448  const char* Behavior(int64_t);
449 
451  std::string Behavior(int64_t, const std::string &strip);
452 
454  const std::vector<int64_t>& Behavior();
455 }}}}}
456 
457 namespace Rose {
458  std::string stringifyBinaryAnalysisHotPatchRecordBehavior(int64_t n, const char *strip=NULL, bool canonic=false);
459  const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordBehavior();
460 }
461 
462 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
463 // /src/Rose/BinaryAnalysis/SRecord.h line 30
464 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
466  const char* Syntax(int64_t);
467 
469  std::string Syntax(int64_t, const std::string &strip);
470 
472  const std::vector<int64_t>& Syntax();
473 }}}}
474 
475 namespace Rose {
476  std::string stringifyBinaryAnalysisSRecordSyntax(int64_t n, const char *strip=NULL, bool canonic=false);
477  const std::vector<int64_t>& stringifyBinaryAnalysisSRecordSyntax();
478 }
479 
480 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
481 // /src/Rose/BinaryAnalysis/SRecord.h line 37
482 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SRecord {
484  const char* Type(int64_t);
485 
487  std::string Type(int64_t, const std::string &strip);
488 
490  const std::vector<int64_t>& Type();
491 }}}}
492 
493 namespace Rose {
494  std::string stringifyBinaryAnalysisSRecordType(int64_t n, const char *strip=NULL, bool canonic=false);
495  const std::vector<int64_t>& stringifyBinaryAnalysisSRecordType();
496 }
497 
498 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
499 // /src/Rose/BinaryAnalysis/SymbolicExpression.h line 62
500 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { namespace TypeStyle {
502  const char* Flag(int64_t);
503 
505  std::string Flag(int64_t, const std::string &strip);
506 
508  const std::vector<int64_t>& Flag();
509 }}}}}
510 
511 namespace Rose {
512  std::string stringifyBinaryAnalysisSymbolicExpressionTypeStyleFlag(int64_t n, const char *strip=NULL, bool canonic=false);
513  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionTypeStyleFlag();
514 }
515 
516 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
517 // /src/Rose/BinaryAnalysis/SymbolicExpression.h line 80
518 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression {
520  const char* Operator(int64_t);
521 
523  std::string Operator(int64_t, const std::string &strip);
524 
526  const std::vector<int64_t>& Operator();
527 }}}}
528 
529 namespace Rose {
530  std::string stringifyBinaryAnalysisSymbolicExpressionOperator(int64_t n, const char *strip=NULL, bool canonic=false);
531  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionOperator();
532 }
533 
534 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
535 // /src/Rose/BinaryAnalysis/SymbolicExpression.h line 165
536 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { namespace Formatter {
538  const char* ShowComments(int64_t);
539 
541  std::string ShowComments(int64_t, const std::string &strip);
542 
544  const std::vector<int64_t>& ShowComments();
545 }}}}}
546 
547 namespace Rose {
548  std::string stringifyBinaryAnalysisSymbolicExpressionFormatterShowComments(int64_t n, const char *strip=NULL, bool canonic=false);
549  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionFormatterShowComments();
550 }
551 
552 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
553 // /src/Rose/BinaryAnalysis/SymbolicExpression.h line 185
554 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression {
556  const char* VisitAction(int64_t);
557 
559  std::string VisitAction(int64_t, const std::string &strip);
560 
562  const std::vector<int64_t>& VisitAction();
563 }}}}
564 
565 namespace Rose {
566  std::string stringifyBinaryAnalysisSymbolicExpressionVisitAction(int64_t n, const char *strip=NULL, bool canonic=false);
567  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionVisitAction();
568 }
569 
570 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
571 // /src/Rose/BinaryAnalysis/SymbolicExpression.h line 227
572 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpression { namespace Type {
574  const char* TypeClass(int64_t);
575 
577  std::string TypeClass(int64_t, const std::string &strip);
578 
580  const std::vector<int64_t>& TypeClass();
581 }}}}}
582 
583 namespace Rose {
584  std::string stringifyBinaryAnalysisSymbolicExpressionTypeTypeClass(int64_t n, const char *strip=NULL, bool canonic=false);
585  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionTypeTypeClass();
586 }
587 
588 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
589 // /src/Rose/BinaryAnalysis/SymbolicExpressionParser.h line 59
590 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SymbolicExpressionParser { namespace Token {
592  const char* Type(int64_t);
593 
595  std::string Type(int64_t, const std::string &strip);
596 
598  const std::vector<int64_t>& Type();
599 }}}}}
600 
601 namespace Rose {
602  std::string stringifyBinaryAnalysisSymbolicExpressionParserTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
603  const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExpressionParserTokenType();
604 }
605 
606 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
607 // /src/Rose/BinaryAnalysis/PointerDetection.h line 182
608 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace PointerDetection { namespace PointerDescriptor {
610  const char* Direction(int64_t);
611 
613  std::string Direction(int64_t, const std::string &strip);
614 
616  const std::vector<int64_t>& Direction();
617 }}}}}
618 
619 namespace Rose {
620  std::string stringifyBinaryAnalysisPointerDetectionPointerDescriptorDirection(int64_t n, const char *strip=NULL, bool canonic=false);
621  const std::vector<int64_t>& stringifyBinaryAnalysisPointerDetectionPointerDescriptorDirection();
622 }
623 
624 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
625 // /src/Rose/BinaryAnalysis/ModelChecker/PartitionerModel.h line 33
626 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker { namespace PartitionerModel { namespace Settings {
628  const char* MemoryType(int64_t);
629 
631  std::string MemoryType(int64_t, const std::string &strip);
632 
634  const std::vector<int64_t>& MemoryType();
635 }}}}}}
636 
637 namespace Rose {
638  std::string stringifyBinaryAnalysisModelCheckerPartitionerModelSettingsMemoryType(int64_t n, const char *strip=NULL, bool canonic=false);
639  const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerPartitionerModelSettingsMemoryType();
640 }
641 
642 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
643 // /src/Rose/BinaryAnalysis/ModelChecker/Types.h line 122
644 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
646  const char* TestMode(int64_t);
647 
649  std::string TestMode(int64_t, const std::string &strip);
650 
652  const std::vector<int64_t>& TestMode();
653 }}}}
654 
655 namespace Rose {
656  std::string stringifyBinaryAnalysisModelCheckerTestMode(int64_t n, const char *strip=NULL, bool canonic=false);
657  const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerTestMode();
658 }
659 
660 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
661 // /src/Rose/BinaryAnalysis/ModelChecker/Types.h line 129
662 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
664  const char* IoMode(int64_t);
665 
667  std::string IoMode(int64_t, const std::string &strip);
668 
670  const std::vector<int64_t>& IoMode();
671 }}}}
672 
673 namespace Rose {
674  std::string stringifyBinaryAnalysisModelCheckerIoMode(int64_t n, const char *strip=NULL, bool canonic=false);
675  const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerIoMode();
676 }
677 
678 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
679 // /src/Rose/BinaryAnalysis/ModelChecker/Types.h line 136
680 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ModelChecker {
682  const char* WorkerState(int64_t);
683 
685  std::string WorkerState(int64_t, const std::string &strip);
686 
688  const std::vector<int64_t>& WorkerState();
689 }}}}
690 
691 namespace Rose {
692  std::string stringifyBinaryAnalysisModelCheckerWorkerState(int64_t n, const char *strip=NULL, bool canonic=false);
693  const std::vector<int64_t>& stringifyBinaryAnalysisModelCheckerWorkerState();
694 }
695 
696 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
697 // /src/Rose/BinaryAnalysis/MemoryMap.h line 131
698 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap { namespace Attach {
700  const char* Boolean(int64_t);
701 
703  std::string Boolean(int64_t, const std::string &strip);
704 
706  const std::vector<int64_t>& Boolean();
707 }}}}}
708 
709 namespace Rose {
710  std::string stringifyBinaryAnalysisMemoryMapAttachBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
711  const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapAttachBoolean();
712 }
713 
714 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
715 // /src/Rose/BinaryAnalysis/MemoryMap.h line 287
716 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MemoryMap {
718  const char* InsertFileMapMode(int64_t);
719 
721  std::string InsertFileMapMode(int64_t, const std::string &strip);
722 
724  const std::vector<int64_t>& InsertFileMapMode();
725 }}}}
726 
727 namespace Rose {
728  std::string stringifyBinaryAnalysisMemoryMapInsertFileMapMode(int64_t n, const char *strip=NULL, bool canonic=false);
729  const std::vector<int64_t>& stringifyBinaryAnalysisMemoryMapInsertFileMapMode();
730 }
731 
732 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
733 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 18
734 namespace stringify { namespace Rose { namespace BinaryAnalysis {
736  const char* Aarch32Exception(int64_t);
737 
739  std::string Aarch32Exception(int64_t, const std::string &strip);
740 
742  const std::vector<int64_t>& Aarch32Exception();
743 }}}
744 
745 namespace Rose {
746  std::string stringifyBinaryAnalysisAarch32Exception(int64_t n, const char *strip=NULL, bool canonic=false);
747  const std::vector<int64_t>& stringifyBinaryAnalysisAarch32Exception();
748 }
749 
750 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
751 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 25
752 namespace stringify { namespace Rose { namespace BinaryAnalysis {
754  const char* Aarch32RegisterClass(int64_t);
755 
757  std::string Aarch32RegisterClass(int64_t, const std::string &strip);
758 
760  const std::vector<int64_t>& Aarch32RegisterClass();
761 }}}
762 
763 namespace Rose {
764  std::string stringifyBinaryAnalysisAarch32RegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
765  const std::vector<int64_t>& stringifyBinaryAnalysisAarch32RegisterClass();
766 }
767 
768 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
769 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 34
770 namespace stringify { namespace Rose { namespace BinaryAnalysis {
772  const char* Aarch32GeneralPurposeRegister(int64_t);
773 
775  std::string Aarch32GeneralPurposeRegister(int64_t, const std::string &strip);
776 
778  const std::vector<int64_t>& Aarch32GeneralPurposeRegister();
779 }}}
780 
781 namespace Rose {
782  std::string stringifyBinaryAnalysisAarch32GeneralPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
783  const std::vector<int64_t>& stringifyBinaryAnalysisAarch32GeneralPurposeRegister();
784 }
785 
786 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
787 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 45
788 namespace stringify { namespace Rose { namespace BinaryAnalysis {
790  const char* Aarch32DebugRegister(int64_t);
791 
793  std::string Aarch32DebugRegister(int64_t, const std::string &strip);
794 
796  const std::vector<int64_t>& Aarch32DebugRegister();
797 }}}
798 
799 namespace Rose {
800  std::string stringifyBinaryAnalysisAarch32DebugRegister(int64_t n, const char *strip=NULL, bool canonic=false);
801  const std::vector<int64_t>& stringifyBinaryAnalysisAarch32DebugRegister();
802 }
803 
804 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
805 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch32.h line 103
806 namespace stringify { namespace Rose { namespace BinaryAnalysis {
808  const char* Aarch32SystemRegister(int64_t);
809 
811  std::string Aarch32SystemRegister(int64_t, const std::string &strip);
812 
814  const std::vector<int64_t>& Aarch32SystemRegister();
815 }}}
816 
817 namespace Rose {
818  std::string stringifyBinaryAnalysisAarch32SystemRegister(int64_t n, const char *strip=NULL, bool canonic=false);
819  const std::vector<int64_t>& stringifyBinaryAnalysisAarch32SystemRegister();
820 }
821 
822 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
823 // /src/Rose/BinaryAnalysis/InstructionSemantics/DataFlowSemantics.h line 37
824 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DataFlowSemantics { namespace DataFlowEdge {
826  const char* EdgeType(int64_t);
827 
829  std::string EdgeType(int64_t, const std::string &strip);
830 
832  const std::vector<int64_t>& EdgeType();
833 }}}}}}
834 
835 namespace Rose {
836  std::string stringifyBinaryAnalysisInstructionSemanticsDataFlowSemanticsDataFlowEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
837  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDataFlowSemanticsDataFlowEdgeEdgeType();
838 }
839 
840 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
841 // /src/Rose/BinaryAnalysis/InstructionSemantics/IntervalSemantics.C line 733
842 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace IntervalSemantics {
844  const char* Carry(int64_t);
845 
847  std::string Carry(int64_t, const std::string &strip);
848 
850  const std::vector<int64_t>& Carry();
851 }}}}}
852 
853 namespace Rose {
854  std::string stringifyBinaryAnalysisInstructionSemanticsIntervalSemanticsCarry(int64_t n, const char *strip=NULL, bool canonic=false);
855  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsIntervalSemanticsCarry();
856 }
857 
858 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
859 // /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 64
860 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace SymbolicSemantics { namespace AllowSideEffects {
862  const char* Flag(int64_t);
863 
865  std::string Flag(int64_t, const std::string &strip);
866 
868  const std::vector<int64_t>& Flag();
869 }}}}}}
870 
871 namespace Rose {
872  std::string stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsAllowSideEffectsFlag(int64_t n, const char *strip=NULL, bool canonic=false);
873  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsAllowSideEffectsFlag();
874 }
875 
876 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
877 // /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 820
878 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace SymbolicSemantics {
880  const char* WritersMode(int64_t);
881 
883  std::string WritersMode(int64_t, const std::string &strip);
884 
886  const std::vector<int64_t>& WritersMode();
887 }}}}}
888 
889 namespace Rose {
890  std::string stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsWritersMode(int64_t n, const char *strip=NULL, bool canonic=false);
891  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsWritersMode();
892 }
893 
894 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
895 // /src/Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h line 827
896 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace SymbolicSemantics {
898  const char* DefinersMode(int64_t);
899 
901  std::string DefinersMode(int64_t, const std::string &strip);
902 
904  const std::vector<int64_t>& DefinersMode();
905 }}}}}
906 
907 namespace Rose {
908  std::string stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsDefinersMode(int64_t n, const char *strip=NULL, bool canonic=false);
909  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSymbolicSemanticsDefinersMode();
910 }
911 
912 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
913 // /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherX86.h line 163
914 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DispatcherX86 {
916  const char* AccessMode(int64_t);
917 
919  std::string AccessMode(int64_t, const std::string &strip);
920 
922  const std::vector<int64_t>& AccessMode();
923 }}}}}
924 
925 namespace Rose {
926  std::string stringifyBinaryAnalysisInstructionSemanticsDispatcherX86AccessMode(int64_t n, const char *strip=NULL, bool canonic=false);
927  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherX86AccessMode();
928 }
929 
930 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
931 // /src/Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/Types.h line 80
932 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace BaseSemantics {
934  const char* InputOutputProperty(int64_t);
935 
937  std::string InputOutputProperty(int64_t, const std::string &strip);
938 
940  const std::vector<int64_t>& InputOutputProperty();
941 }}}}}
942 
943 namespace Rose {
944  std::string stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsInputOutputProperty(int64_t n, const char *strip=NULL, bool canonic=false);
945  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsInputOutputProperty();
946 }
947 
948 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
949 // /src/Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RiscOperators.h line 483
950 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace BaseSemantics { namespace RiscOperators {
952  const char* IteStatus(int64_t);
953 
955  std::string IteStatus(int64_t, const std::string &strip);
956 
958  const std::vector<int64_t>& IteStatus();
959 }}}}}}
960 
961 namespace Rose {
962  std::string stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsRiscOperatorsIteStatus(int64_t n, const char *strip=NULL, bool canonic=false);
963  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsBaseSemanticsRiscOperatorsIteStatus();
964 }
965 
966 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
967 // /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherAarch32.h line 158
968 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DispatcherAarch32 {
970  const char* SrType(int64_t);
971 
973  std::string SrType(int64_t, const std::string &strip);
974 
976  const std::vector<int64_t>& SrType();
977 }}}}}
978 
979 namespace Rose {
980  std::string stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32SrType(int64_t n, const char *strip=NULL, bool canonic=false);
981  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32SrType();
982 }
983 
984 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
985 // /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherAarch32.h line 159
986 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace DispatcherAarch32 {
988  const char* BranchType(int64_t);
989 
991  std::string BranchType(int64_t, const std::string &strip);
992 
994  const std::vector<int64_t>& BranchType();
995 }}}}}
996 
997 namespace Rose {
998  std::string stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32BranchType(int64_t n, const char *strip=NULL, bool canonic=false);
999  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsDispatcherAarch32BranchType();
1000 }
1001 
1002 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1003 // /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherPowerpc.C line 20
1004 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace UpdateCr {
1006  const char* Flag(int64_t);
1007 
1009  std::string Flag(int64_t, const std::string &strip);
1010 
1012  const std::vector<int64_t>& Flag();
1013 }}}}}
1014 
1015 namespace Rose {
1016  std::string stringifyBinaryAnalysisInstructionSemanticsUpdateCrFlag(int64_t n, const char *strip=NULL, bool canonic=false);
1017  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsUpdateCrFlag();
1018 }
1019 
1020 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1021 // /src/Rose/BinaryAnalysis/InstructionSemantics/DispatcherPowerpc.C line 24
1022 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace SaveLink {
1024  const char* Flag(int64_t);
1025 
1027  std::string Flag(int64_t, const std::string &strip);
1028 
1030  const std::vector<int64_t>& Flag();
1031 }}}}}
1032 
1033 namespace Rose {
1034  std::string stringifyBinaryAnalysisInstructionSemanticsSaveLinkFlag(int64_t n, const char *strip=NULL, bool canonic=false);
1035  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsSaveLinkFlag();
1036 }
1037 
1038 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1039 // /src/Rose/BinaryAnalysis/InstructionSemantics/TaintSemantics.h line 18
1040 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace InstructionSemantics { namespace TaintSemantics {
1042  const char* Taintedness(int64_t);
1043 
1045  std::string Taintedness(int64_t, const std::string &strip);
1046 
1048  const std::vector<int64_t>& Taintedness();
1049 }}}}}
1050 
1051 namespace Rose {
1052  std::string stringifyBinaryAnalysisInstructionSemanticsTaintSemanticsTaintedness(int64_t n, const char *strip=NULL, bool canonic=false);
1053  const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemanticsTaintSemanticsTaintedness();
1054 }
1055 
1056 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1057 // /src/Rose/BinaryAnalysis/Unparser/Base.h line 54
1058 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace ArrowMargin {
1060  const char* Flags(int64_t);
1061 
1063  std::string Flags(int64_t, const std::string &strip);
1064 
1066  const std::vector<int64_t>& Flags();
1067 }}}}}
1068 
1069 namespace Rose {
1070  std::string stringifyBinaryAnalysisUnparserArrowMarginFlags(int64_t n, const char *strip=NULL, bool canonic=false);
1071  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserArrowMarginFlags();
1072 }
1073 
1074 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1075 // /src/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 33
1076 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
1078  const char* OutputPart(int64_t);
1079 
1081  std::string OutputPart(int64_t, const std::string &strip);
1082 
1084  const std::vector<int64_t>& OutputPart();
1085 }}}}}
1086 
1087 namespace Rose {
1088  std::string stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart(int64_t n, const char *strip=NULL, bool canonic=false);
1089  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsOutputPart();
1090 }
1091 
1092 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1093 // /src/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 61
1094 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
1096  const char* ArrowStylePreset(int64_t);
1097 
1099  std::string ArrowStylePreset(int64_t, const std::string &strip);
1100 
1102  const std::vector<int64_t>& ArrowStylePreset();
1103 }}}}}
1104 
1105 namespace Rose {
1106  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset(int64_t n, const char *strip=NULL, bool canonic=false);
1107  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowStylePreset();
1108 }
1109 
1110 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1111 // /src/Rose/BinaryAnalysis/Unparser/EdgeArrows.h line 70
1112 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Unparser { namespace EdgeArrows {
1114  const char* ArrowSide(int64_t);
1115 
1117  std::string ArrowSide(int64_t, const std::string &strip);
1118 
1120  const std::vector<int64_t>& ArrowSide();
1121 }}}}}
1122 
1123 namespace Rose {
1124  std::string stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide(int64_t n, const char *strip=NULL, bool canonic=false);
1125  const std::vector<int64_t>& stringifyBinaryAnalysisUnparserEdgeArrowsArrowSide();
1126 }
1127 
1128 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1129 // /src/Rose/BinaryAnalysis/Partitioner2/Reference.h line 31
1130 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Reference {
1132  const char* Granularity(int64_t);
1133 
1135  std::string Granularity(int64_t, const std::string &strip);
1136 
1138  const std::vector<int64_t>& Granularity();
1139 }}}}}
1140 
1141 namespace Rose {
1142  std::string stringifyBinaryAnalysisPartitioner2ReferenceGranularity(int64_t n, const char *strip=NULL, bool canonic=false);
1143  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2ReferenceGranularity();
1144 }
1145 
1146 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1147 // /src/Rose/BinaryAnalysis/Partitioner2/Modules.h line 48
1148 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace BasicBlockCallback {
1150  const char* Termination(int64_t);
1151 
1153  std::string Termination(int64_t, const std::string &strip);
1154 
1156  const std::vector<int64_t>& Termination();
1157 }}}}}
1158 
1159 namespace Rose {
1160  std::string stringifyBinaryAnalysisPartitioner2BasicBlockCallbackTermination(int64_t n, const char *strip=NULL, bool canonic=false);
1161  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2BasicBlockCallbackTermination();
1162 }
1163 
1164 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1165 // /src/Rose/BinaryAnalysis/Partitioner2/CfgPath.h line 456
1166 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Inliner {
1168  const char* HowInline(int64_t);
1169 
1171  std::string HowInline(int64_t, const std::string &strip);
1172 
1174  const std::vector<int64_t>& HowInline();
1175 }}}}}
1176 
1177 namespace Rose {
1178  std::string stringifyBinaryAnalysisPartitioner2InlinerHowInline(int64_t n, const char *strip=NULL, bool canonic=false);
1179  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2InlinerHowInline();
1180 }
1181 
1182 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1183 // /src/Rose/BinaryAnalysis/Partitioner2/DataFlow.h line 29
1184 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace DataFlow { namespace DfCfgVertex {
1186  const char* Type(int64_t);
1187 
1189  std::string Type(int64_t, const std::string &strip);
1190 
1192  const std::vector<int64_t>& Type();
1193 }}}}}}
1194 
1195 namespace Rose {
1196  std::string stringifyBinaryAnalysisPartitioner2DataFlowDfCfgVertexType(int64_t n, const char *strip=NULL, bool canonic=false);
1197  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2DataFlowDfCfgVertexType();
1198 }
1199 
1200 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1201 // /src/Rose/BinaryAnalysis/Partitioner2/ModulesElf.h line 88
1202 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace ModulesElf { namespace FixUndefinedSymbols {
1204  const char* Boolean(int64_t);
1205 
1207  std::string Boolean(int64_t, const std::string &strip);
1208 
1210  const std::vector<int64_t>& Boolean();
1211 }}}}}}
1212 
1213 namespace Rose {
1214  std::string stringifyBinaryAnalysisPartitioner2ModulesElfFixUndefinedSymbolsBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
1215  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2ModulesElfFixUndefinedSymbolsBoolean();
1216 }
1217 
1218 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1219 // /src/Rose/BinaryAnalysis/Partitioner2/Partitioner.h line 1468
1220 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Partitioner { namespace MayReturnVertexInfo {
1222  const char* State(int64_t);
1223 
1225  std::string State(int64_t, const std::string &strip);
1226 
1228  const std::vector<int64_t>& State();
1229 }}}}}}
1230 
1231 namespace Rose {
1232  std::string stringifyBinaryAnalysisPartitioner2PartitionerMayReturnVertexInfoState(int64_t n, const char *strip=NULL, bool canonic=false);
1233  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2PartitionerMayReturnVertexInfoState();
1234 }
1235 
1236 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1237 // /src/Rose/BinaryAnalysis/Partitioner2/ParallelPartitioner.h line 30
1238 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Experimental { namespace ParallelPartitioner {
1240  const char* Accuracy(int64_t);
1241 
1243  std::string Accuracy(int64_t, const std::string &strip);
1244 
1246  const std::vector<int64_t>& Accuracy();
1247 }}}}}}
1248 
1249 namespace Rose {
1250  std::string stringifyBinaryAnalysisPartitioner2ExperimentalParallelPartitionerAccuracy(int64_t n, const char *strip=NULL, bool canonic=false);
1251  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2ExperimentalParallelPartitionerAccuracy();
1252 }
1253 
1254 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1255 // /src/Rose/BinaryAnalysis/Partitioner2/ParallelPartitioner.h line 492
1256 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Experimental { namespace ParallelPartitioner { namespace WorkItem {
1258  const char* Priority(int64_t);
1259 
1261  std::string Priority(int64_t, const std::string &strip);
1262 
1264  const std::vector<int64_t>& Priority();
1265 }}}}}}}
1266 
1267 namespace Rose {
1268  std::string stringifyBinaryAnalysisPartitioner2ExperimentalParallelPartitionerWorkItemPriority(int64_t n, const char *strip=NULL, bool canonic=false);
1269  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2ExperimentalParallelPartitionerWorkItemPriority();
1270 }
1271 
1272 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1273 // /src/Rose/BinaryAnalysis/Partitioner2/Function.h line 45
1274 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Function {
1276  const char* Ownership(int64_t);
1277 
1279  std::string Ownership(int64_t, const std::string &strip);
1280 
1282  const std::vector<int64_t>& Ownership();
1283 }}}}}
1284 
1285 namespace Rose {
1286  std::string stringifyBinaryAnalysisPartitioner2FunctionOwnership(int64_t n, const char *strip=NULL, bool canonic=false);
1287  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2FunctionOwnership();
1288 }
1289 
1290 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1291 // /src/Rose/BinaryAnalysis/Partitioner2/ModulesX86.h line 99
1292 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace ModulesX86 { namespace SwitchSuccessors {
1294  const char* EntryType(int64_t);
1295 
1297  std::string EntryType(int64_t, const std::string &strip);
1298 
1300  const std::vector<int64_t>& EntryType();
1301 }}}}}}
1302 
1303 namespace Rose {
1304  std::string stringifyBinaryAnalysisPartitioner2ModulesX86SwitchSuccessorsEntryType(int64_t n, const char *strip=NULL, bool canonic=false);
1305  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2ModulesX86SwitchSuccessorsEntryType();
1306 }
1307 
1308 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1309 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 57
1310 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace Precision {
1312  const char* Level(int64_t);
1313 
1315  std::string Level(int64_t, const std::string &strip);
1316 
1318  const std::vector<int64_t>& Level();
1319 }}}}}
1320 
1321 namespace Rose {
1322  std::string stringifyBinaryAnalysisPartitioner2PrecisionLevel(int64_t n, const char *strip=NULL, bool canonic=false);
1323  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2PrecisionLevel();
1324 }
1325 
1326 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1327 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 67
1328 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 { namespace AllowParallelEdges {
1330  const char* Type(int64_t);
1331 
1333  std::string Type(int64_t, const std::string &strip);
1334 
1336  const std::vector<int64_t>& Type();
1337 }}}}}
1338 
1339 namespace Rose {
1340  std::string stringifyBinaryAnalysisPartitioner2AllowParallelEdgesType(int64_t n, const char *strip=NULL, bool canonic=false);
1341  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2AllowParallelEdgesType();
1342 }
1343 
1344 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1345 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 74
1346 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1348  const char* VertexType(int64_t);
1349 
1351  std::string VertexType(int64_t, const std::string &strip);
1352 
1354  const std::vector<int64_t>& VertexType();
1355 }}}}
1356 
1357 namespace Rose {
1358  std::string stringifyBinaryAnalysisPartitioner2VertexType(int64_t n, const char *strip=NULL, bool canonic=false);
1359  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2VertexType();
1360 }
1361 
1362 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1363 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 85
1364 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1366  const char* EdgeType(int64_t);
1367 
1369  std::string EdgeType(int64_t, const std::string &strip);
1370 
1372  const std::vector<int64_t>& EdgeType();
1373 }}}}
1374 
1375 namespace Rose {
1376  std::string stringifyBinaryAnalysisPartitioner2EdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
1377  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2EdgeType();
1378 }
1379 
1380 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1381 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 109
1382 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1384  const char* Confidence(int64_t);
1385 
1387  std::string Confidence(int64_t, const std::string &strip);
1388 
1390  const std::vector<int64_t>& Confidence();
1391 }}}}
1392 
1393 namespace Rose {
1394  std::string stringifyBinaryAnalysisPartitioner2Confidence(int64_t n, const char *strip=NULL, bool canonic=false);
1395  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2Confidence();
1396 }
1397 
1398 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1399 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 115
1400 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1402  const char* SemanticMemoryParadigm(int64_t);
1403 
1405  std::string SemanticMemoryParadigm(int64_t, const std::string &strip);
1406 
1408  const std::vector<int64_t>& SemanticMemoryParadigm();
1409 }}}}
1410 
1411 namespace Rose {
1412  std::string stringifyBinaryAnalysisPartitioner2SemanticMemoryParadigm(int64_t n, const char *strip=NULL, bool canonic=false);
1413  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2SemanticMemoryParadigm();
1414 }
1415 
1416 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1417 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 213
1418 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1420  const char* MemoryDataAdjustment(int64_t);
1421 
1423  std::string MemoryDataAdjustment(int64_t, const std::string &strip);
1424 
1426  const std::vector<int64_t>& MemoryDataAdjustment();
1427 }}}}
1428 
1429 namespace Rose {
1430  std::string stringifyBinaryAnalysisPartitioner2MemoryDataAdjustment(int64_t n, const char *strip=NULL, bool canonic=false);
1431  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2MemoryDataAdjustment();
1432 }
1433 
1434 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1435 // /src/Rose/BinaryAnalysis/Partitioner2/BasicTypes.h line 331
1436 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Partitioner2 {
1438  const char* FunctionReturnAnalysis(int64_t);
1439 
1441  std::string FunctionReturnAnalysis(int64_t, const std::string &strip);
1442 
1444  const std::vector<int64_t>& FunctionReturnAnalysis();
1445 }}}}
1446 
1447 namespace Rose {
1448  std::string stringifyBinaryAnalysisPartitioner2FunctionReturnAnalysis(int64_t n, const char *strip=NULL, bool canonic=false);
1449  const std::vector<int64_t>& stringifyBinaryAnalysisPartitioner2FunctionReturnAnalysis();
1450 }
1451 
1452 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1453 // /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 12
1454 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
1456  const char* DWARF_TAG(int64_t);
1457 
1459  std::string DWARF_TAG(int64_t, const std::string &strip);
1460 
1462  const std::vector<int64_t>& DWARF_TAG();
1463 }}}}
1464 
1465 namespace Rose {
1466  std::string stringifyBinaryAnalysisDwarfDWARF_TAG(int64_t n, const char *strip=NULL, bool canonic=false);
1467  const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_TAG();
1468 }
1469 
1470 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1471 // /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 115
1472 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
1474  const char* DWARF_FORM(int64_t);
1475 
1477  std::string DWARF_FORM(int64_t, const std::string &strip);
1478 
1480  const std::vector<int64_t>& DWARF_FORM();
1481 }}}}
1482 
1483 namespace Rose {
1484  std::string stringifyBinaryAnalysisDwarfDWARF_FORM(int64_t n, const char *strip=NULL, bool canonic=false);
1485  const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_FORM();
1486 }
1487 
1488 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1489 // /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 144
1490 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
1492  const char* DWARF_AT(int64_t);
1493 
1495  std::string DWARF_AT(int64_t, const std::string &strip);
1496 
1498  const std::vector<int64_t>& DWARF_AT();
1499 }}}}
1500 
1501 namespace Rose {
1502  std::string stringifyBinaryAnalysisDwarfDWARF_AT(int64_t n, const char *strip=NULL, bool canonic=false);
1503  const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_AT();
1504 }
1505 
1506 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1507 // /src/Rose/BinaryAnalysis/Dwarf/Constants.h line 358
1508 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Dwarf {
1510  const char* DWARF_LANG(int64_t);
1511 
1513  std::string DWARF_LANG(int64_t, const std::string &strip);
1514 
1516  const std::vector<int64_t>& DWARF_LANG();
1517 }}}}
1518 
1519 namespace Rose {
1520  std::string stringifyBinaryAnalysisDwarfDWARF_LANG(int64_t n, const char *strip=NULL, bool canonic=false);
1521  const std::vector<int64_t>& stringifyBinaryAnalysisDwarfDWARF_LANG();
1522 }
1523 
1524 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1525 // /src/Rose/BinaryAnalysis/SmtSolver.h line 51
1526 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
1528  const char* LinkMode(int64_t);
1529 
1531  std::string LinkMode(int64_t, const std::string &strip);
1532 
1534  const std::vector<int64_t>& LinkMode();
1535 }}}}
1536 
1537 namespace Rose {
1538  std::string stringifyBinaryAnalysisSmtSolverLinkMode(int64_t n, const char *strip=NULL, bool canonic=false);
1539  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverLinkMode();
1540 }
1541 
1542 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1543 // /src/Rose/BinaryAnalysis/SmtSolver.h line 63
1544 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
1546  const char* Type(int64_t);
1547 
1549  std::string Type(int64_t, const std::string &strip);
1550 
1552  const std::vector<int64_t>& Type();
1553 }}}}
1554 
1555 namespace Rose {
1556  std::string stringifyBinaryAnalysisSmtSolverType(int64_t n, const char *strip=NULL, bool canonic=false);
1557  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverType();
1558 }
1559 
1560 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1561 // /src/Rose/BinaryAnalysis/SmtSolver.h line 87
1562 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SmtSolver {
1564  const char* Satisfiable(int64_t);
1565 
1567  std::string Satisfiable(int64_t, const std::string &strip);
1568 
1570  const std::vector<int64_t>& Satisfiable();
1571 }}}}
1572 
1573 namespace Rose {
1574  std::string stringifyBinaryAnalysisSmtSolverSatisfiable(int64_t n, const char *strip=NULL, bool canonic=false);
1575  const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverSatisfiable();
1576 }
1577 
1578 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1579 // /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 11
1580 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1582  const char* MipsRegisterClass(int64_t);
1583 
1585  std::string MipsRegisterClass(int64_t, const std::string &strip);
1586 
1588  const std::vector<int64_t>& MipsRegisterClass();
1589 }}}
1590 
1591 namespace Rose {
1592  std::string stringifyBinaryAnalysisMipsRegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
1593  const std::vector<int64_t>& stringifyBinaryAnalysisMipsRegisterClass();
1594 }
1595 
1596 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1597 // /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 24
1598 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1600  const char* MipsFcsrMinors(int64_t);
1601 
1603  std::string MipsFcsrMinors(int64_t, const std::string &strip);
1604 
1606  const std::vector<int64_t>& MipsFcsrMinors();
1607 }}}
1608 
1609 namespace Rose {
1610  std::string stringifyBinaryAnalysisMipsFcsrMinors(int64_t n, const char *strip=NULL, bool canonic=false);
1611  const std::vector<int64_t>& stringifyBinaryAnalysisMipsFcsrMinors();
1612 }
1613 
1614 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1615 // /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 32
1616 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1618  const char* MipsSpecialPurposeRegister(int64_t);
1619 
1621  std::string MipsSpecialPurposeRegister(int64_t, const std::string &strip);
1622 
1624  const std::vector<int64_t>& MipsSpecialPurposeRegister();
1625 }}}
1626 
1627 namespace Rose {
1628  std::string stringifyBinaryAnalysisMipsSpecialPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
1629  const std::vector<int64_t>& stringifyBinaryAnalysisMipsSpecialPurposeRegister();
1630 }
1631 
1632 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1633 // /src/Rose/BinaryAnalysis/InstructionEnumsMips.h line 41
1634 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1636  const char* MipsInstructionKind(int64_t);
1637 
1639  std::string MipsInstructionKind(int64_t, const std::string &strip);
1640 
1642  const std::vector<int64_t>& MipsInstructionKind();
1643 }}}
1644 
1645 namespace Rose {
1646  std::string stringifyBinaryAnalysisMipsInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
1647  const std::vector<int64_t>& stringifyBinaryAnalysisMipsInstructionKind();
1648 }
1649 
1650 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1651 // /src/Rose/BinaryAnalysis/Concolic/ExecutionEvent.h line 70
1652 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic { namespace ExecutionEvent {
1654  const char* Action(int64_t);
1655 
1657  std::string Action(int64_t, const std::string &strip);
1658 
1660  const std::vector<int64_t>& Action();
1661 }}}}}
1662 
1663 namespace Rose {
1664  std::string stringifyBinaryAnalysisConcolicExecutionEventAction(int64_t n, const char *strip=NULL, bool canonic=false);
1665  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicExecutionEventAction();
1666 }
1667 
1668 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1669 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 25
1670 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1672  const char* Update(int64_t);
1673 
1675  std::string Update(int64_t, const std::string &strip);
1676 
1678  const std::vector<int64_t>& Update();
1679 }}}}
1680 
1681 namespace Rose {
1682  std::string stringifyBinaryAnalysisConcolicUpdate(int64_t n, const char *strip=NULL, bool canonic=false);
1683  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdate();
1684 }
1685 
1686 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1687 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 27
1688 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1690  const char* ShowEvents(int64_t);
1691 
1693  std::string ShowEvents(int64_t, const std::string &strip);
1694 
1696  const std::vector<int64_t>& ShowEvents();
1697 }}}}
1698 
1699 namespace Rose {
1700  std::string stringifyBinaryAnalysisConcolicShowEvents(int64_t n, const char *strip=NULL, bool canonic=false);
1701  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicShowEvents();
1702 }
1703 
1704 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1705 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 29
1706 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1708  const char* ShowAssertions(int64_t);
1709 
1711  std::string ShowAssertions(int64_t, const std::string &strip);
1712 
1714  const std::vector<int64_t>& ShowAssertions();
1715 }}}}
1716 
1717 namespace Rose {
1718  std::string stringifyBinaryAnalysisConcolicShowAssertions(int64_t n, const char *strip=NULL, bool canonic=false);
1719  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicShowAssertions();
1720 }
1721 
1722 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1723 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 32
1724 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1726  const char* InputType(int64_t);
1727 
1729  std::string InputType(int64_t, const std::string &strip);
1730 
1732  const std::vector<int64_t>& InputType();
1733 }}}}
1734 
1735 namespace Rose {
1736  std::string stringifyBinaryAnalysisConcolicInputType(int64_t n, const char *strip=NULL, bool canonic=false);
1737  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicInputType();
1738 }
1739 
1740 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1741 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 42
1742 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1744  const char* IoDirection(int64_t);
1745 
1747  std::string IoDirection(int64_t, const std::string &strip);
1748 
1750  const std::vector<int64_t>& IoDirection();
1751 }}}}
1752 
1753 namespace Rose {
1754  std::string stringifyBinaryAnalysisConcolicIoDirection(int64_t n, const char *strip=NULL, bool canonic=false);
1755  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicIoDirection();
1756 }
1757 
1758 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1759 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 50
1760 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1762  const char* When(int64_t);
1763 
1765  std::string When(int64_t, const std::string &strip);
1766 
1768  const std::vector<int64_t>& When();
1769 }}}}
1770 
1771 namespace Rose {
1772  std::string stringifyBinaryAnalysisConcolicWhen(int64_t n, const char *strip=NULL, bool canonic=false);
1773  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicWhen();
1774 }
1775 
1776 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1777 // /src/Rose/BinaryAnalysis/Concolic/BasicTypes.h line 56
1778 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Concolic {
1780  const char* ConcolicPhase(int64_t);
1781 
1783  std::string ConcolicPhase(int64_t, const std::string &strip);
1784 
1786  const std::vector<int64_t>& ConcolicPhase();
1787 }}}}
1788 
1789 namespace Rose {
1790  std::string stringifyBinaryAnalysisConcolicConcolicPhase(int64_t n, const char *strip=NULL, bool canonic=false);
1791  const std::vector<int64_t>& stringifyBinaryAnalysisConcolicConcolicPhase();
1792 }
1793 
1794 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1795 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 18
1796 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1798  const char* M68kFamily(int64_t);
1799 
1801  std::string M68kFamily(int64_t, const std::string &strip);
1802 
1804  const std::vector<int64_t>& M68kFamily();
1805 }}}
1806 
1807 namespace Rose {
1808  std::string stringifyBinaryAnalysisM68kFamily(int64_t n, const char *strip=NULL, bool canonic=false);
1809  const std::vector<int64_t>& stringifyBinaryAnalysisM68kFamily();
1810 }
1811 
1812 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1813 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 56
1814 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1816  const char* M68kRegisterClass(int64_t);
1817 
1819  std::string M68kRegisterClass(int64_t, const std::string &strip);
1820 
1822  const std::vector<int64_t>& M68kRegisterClass();
1823 }}}
1824 
1825 namespace Rose {
1826  std::string stringifyBinaryAnalysisM68kRegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
1827  const std::vector<int64_t>& stringifyBinaryAnalysisM68kRegisterClass();
1828 }
1829 
1830 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1831 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 66
1832 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1834  const char* M68kSpecialPurposeRegister(int64_t);
1835 
1837  std::string M68kSpecialPurposeRegister(int64_t, const std::string &strip);
1838 
1840  const std::vector<int64_t>& M68kSpecialPurposeRegister();
1841 }}}
1842 
1843 namespace Rose {
1844  std::string stringifyBinaryAnalysisM68kSpecialPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
1845  const std::vector<int64_t>& stringifyBinaryAnalysisM68kSpecialPurposeRegister();
1846 }
1847 
1848 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1849 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 75
1850 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1852  const char* M68kMacRegister(int64_t);
1853 
1855  std::string M68kMacRegister(int64_t, const std::string &strip);
1856 
1858  const std::vector<int64_t>& M68kMacRegister();
1859 }}}
1860 
1861 namespace Rose {
1862  std::string stringifyBinaryAnalysisM68kMacRegister(int64_t n, const char *strip=NULL, bool canonic=false);
1863  const std::vector<int64_t>& stringifyBinaryAnalysisM68kMacRegister();
1864 }
1865 
1866 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1867 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 91
1868 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1870  const char* M68kEmacRegister(int64_t);
1871 
1873  std::string M68kEmacRegister(int64_t, const std::string &strip);
1874 
1876  const std::vector<int64_t>& M68kEmacRegister();
1877 }}}
1878 
1879 namespace Rose {
1880  std::string stringifyBinaryAnalysisM68kEmacRegister(int64_t n, const char *strip=NULL, bool canonic=false);
1881  const std::vector<int64_t>& stringifyBinaryAnalysisM68kEmacRegister();
1882 }
1883 
1884 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1885 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 101
1886 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1888  const char* M68kSupervisorRegister(int64_t);
1889 
1891  std::string M68kSupervisorRegister(int64_t, const std::string &strip);
1892 
1894  const std::vector<int64_t>& M68kSupervisorRegister();
1895 }}}
1896 
1897 namespace Rose {
1898  std::string stringifyBinaryAnalysisM68kSupervisorRegister(int64_t n, const char *strip=NULL, bool canonic=false);
1899  const std::vector<int64_t>& stringifyBinaryAnalysisM68kSupervisorRegister();
1900 }
1901 
1902 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1903 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 188
1904 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1906  const char* M68kEffectiveAddressMode(int64_t);
1907 
1909  std::string M68kEffectiveAddressMode(int64_t, const std::string &strip);
1910 
1912  const std::vector<int64_t>& M68kEffectiveAddressMode();
1913 }}}
1914 
1915 namespace Rose {
1916  std::string stringifyBinaryAnalysisM68kEffectiveAddressMode(int64_t n, const char *strip=NULL, bool canonic=false);
1917  const std::vector<int64_t>& stringifyBinaryAnalysisM68kEffectiveAddressMode();
1918 }
1919 
1920 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1921 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 242
1922 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1924  const char* M68kDataFormat(int64_t);
1925 
1927  std::string M68kDataFormat(int64_t, const std::string &strip);
1928 
1930  const std::vector<int64_t>& M68kDataFormat();
1931 }}}
1932 
1933 namespace Rose {
1934  std::string stringifyBinaryAnalysisM68kDataFormat(int64_t n, const char *strip=NULL, bool canonic=false);
1935  const std::vector<int64_t>& stringifyBinaryAnalysisM68kDataFormat();
1936 }
1937 
1938 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1939 // /src/Rose/BinaryAnalysis/InstructionEnumsM68k.h line 254
1940 namespace stringify { namespace Rose { namespace BinaryAnalysis {
1942  const char* M68kInstructionKind(int64_t);
1943 
1945  std::string M68kInstructionKind(int64_t, const std::string &strip);
1946 
1948  const std::vector<int64_t>& M68kInstructionKind();
1949 }}}
1950 
1951 namespace Rose {
1952  std::string stringifyBinaryAnalysisM68kInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
1953  const std::vector<int64_t>& stringifyBinaryAnalysisM68kInstructionKind();
1954 }
1955 
1956 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1957 // /src/Rose/BinaryAnalysis/RegisterDictionary.h line 345
1958 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace RegisterDictionary { namespace SortBySize {
1960  const char* Direction(int64_t);
1961 
1963  std::string Direction(int64_t, const std::string &strip);
1964 
1966  const std::vector<int64_t>& Direction();
1967 }}}}}
1968 
1969 namespace Rose {
1970  std::string stringifyBinaryAnalysisRegisterDictionarySortBySizeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
1971  const std::vector<int64_t>& stringifyBinaryAnalysisRegisterDictionarySortBySizeDirection();
1972 }
1973 
1974 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1975 // /src/Rose/BinaryAnalysis/Debugger/Gdb.h line 126
1976 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Gdb { namespace Response { namespace ResultRecord {
1978  const char* ResultClass(int64_t);
1979 
1981  std::string ResultClass(int64_t, const std::string &strip);
1982 
1984  const std::vector<int64_t>& ResultClass();
1985 }}}}}}}
1986 
1987 namespace Rose {
1988  std::string stringifyBinaryAnalysisDebuggerGdbResponseResultRecordResultClass(int64_t n, const char *strip=NULL, bool canonic=false);
1989  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseResultRecordResultClass();
1990 }
1991 
1992 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
1993 // /src/Rose/BinaryAnalysis/Debugger/Linux.h line 24
1994 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
1996  const char* DetachMode(int64_t);
1997 
1999  std::string DetachMode(int64_t, const std::string &strip);
2000 
2002  const std::vector<int64_t>& DetachMode();
2003 }}}}}
2004 
2005 namespace Rose {
2006  std::string stringifyBinaryAnalysisDebuggerLinuxDetachMode(int64_t n, const char *strip=NULL, bool canonic=false);
2007  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxDetachMode();
2008 }
2009 
2010 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2011 // /src/Rose/BinaryAnalysis/Debugger/Linux.h line 32
2012 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
2014  const char* Flag(int64_t);
2015 
2017  std::string Flag(int64_t, const std::string &strip);
2018 
2020  const std::vector<int64_t>& Flag();
2021 }}}}}
2022 
2023 namespace Rose {
2024  std::string stringifyBinaryAnalysisDebuggerLinuxFlag(int64_t n, const char *strip=NULL, bool canonic=false);
2025  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxFlag();
2026 }
2027 
2028 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2029 // /src/Rose/BinaryAnalysis/Debugger/Linux.h line 195
2030 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace Linux {
2032  const char* RegPage(int64_t);
2033 
2035  std::string RegPage(int64_t, const std::string &strip);
2036 
2038  const std::vector<int64_t>& RegPage();
2039 }}}}}
2040 
2041 namespace Rose {
2042  std::string stringifyBinaryAnalysisDebuggerLinuxRegPage(int64_t n, const char *strip=NULL, bool canonic=false);
2043  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerLinuxRegPage();
2044 }
2045 
2046 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2047 // /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 19
2048 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
2050  const char* TokenType(int64_t);
2051 
2053  std::string TokenType(int64_t, const std::string &strip);
2054 
2056  const std::vector<int64_t>& TokenType();
2057 }}}}}
2058 
2059 namespace Rose {
2060  std::string stringifyBinaryAnalysisDebuggerGdbResponseTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
2061  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseTokenType();
2062 }
2063 
2064 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2065 // /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 82
2066 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
2068  const char* ResultClass(int64_t);
2069 
2071  std::string ResultClass(int64_t, const std::string &strip);
2072 
2074  const std::vector<int64_t>& ResultClass();
2075 }}}}}
2076 
2077 namespace Rose {
2078  std::string stringifyBinaryAnalysisDebuggerGdbResponseResultClass(int64_t n, const char *strip=NULL, bool canonic=false);
2079  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseResultClass();
2080 }
2081 
2082 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2083 // /src/Rose/BinaryAnalysis/Debugger/GdbResponse.h line 85
2084 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger { namespace GdbResponse {
2086  const char* AsyncClass(int64_t);
2087 
2089  std::string AsyncClass(int64_t, const std::string &strip);
2090 
2092  const std::vector<int64_t>& AsyncClass();
2093 }}}}}
2094 
2095 namespace Rose {
2096  std::string stringifyBinaryAnalysisDebuggerGdbResponseAsyncClass(int64_t n, const char *strip=NULL, bool canonic=false);
2097  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerGdbResponseAsyncClass();
2098 }
2099 
2100 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2101 // /src/Rose/BinaryAnalysis/Debugger/BasicTypes.h line 38
2102 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Debugger {
2104  const char* FilterActionFlag(int64_t);
2105 
2107  std::string FilterActionFlag(int64_t, const std::string &strip);
2108 
2110  const std::vector<int64_t>& FilterActionFlag();
2111 }}}}
2112 
2113 namespace Rose {
2114  std::string stringifyBinaryAnalysisDebuggerFilterActionFlag(int64_t n, const char *strip=NULL, bool canonic=false);
2115  const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFilterActionFlag();
2116 }
2117 
2118 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2119 // /src/Rose/BinaryAnalysis/InstructionCache.h line 44
2120 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ManagedInstruction {
2122  const char* State(int64_t);
2123 
2125  std::string State(int64_t, const std::string &strip);
2126 
2128  const std::vector<int64_t>& State();
2129 }}}}
2130 
2131 namespace Rose {
2132  std::string stringifyBinaryAnalysisManagedInstructionState(int64_t n, const char *strip=NULL, bool canonic=false);
2133  const std::vector<int64_t>& stringifyBinaryAnalysisManagedInstructionState();
2134 }
2135 
2136 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2137 // /src/Rose/BinaryAnalysis/String.h line 198
2138 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Strings {
2140  const char* State(int64_t);
2141 
2143  std::string State(int64_t, const std::string &strip);
2144 
2146  const std::vector<int64_t>& State();
2147 }}}}
2148 
2149 namespace Rose {
2150  std::string stringifyBinaryAnalysisStringsState(int64_t n, const char *strip=NULL, bool canonic=false);
2151  const std::vector<int64_t>& stringifyBinaryAnalysisStringsState();
2152 }
2153 
2154 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2155 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 12
2156 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2158  const char* PowerpcWordSize(int64_t);
2159 
2161  std::string PowerpcWordSize(int64_t, const std::string &strip);
2162 
2164  const std::vector<int64_t>& PowerpcWordSize();
2165 }}}
2166 
2167 namespace Rose {
2168  std::string stringifyBinaryAnalysisPowerpcWordSize(int64_t n, const char *strip=NULL, bool canonic=false);
2169  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcWordSize();
2170 }
2171 
2172 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2173 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 18
2174 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2176  const char* PowerpcInstructionKind(int64_t);
2177 
2179  std::string PowerpcInstructionKind(int64_t, const std::string &strip);
2180 
2182  const std::vector<int64_t>& PowerpcInstructionKind();
2183 }}}
2184 
2185 namespace Rose {
2186  std::string stringifyBinaryAnalysisPowerpcInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
2187  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcInstructionKind();
2188 }
2189 
2190 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2191 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 465
2192 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2194  const char* PowerpcRegisterClass(int64_t);
2195 
2197  std::string PowerpcRegisterClass(int64_t, const std::string &strip);
2198 
2200  const std::vector<int64_t>& PowerpcRegisterClass();
2201 }}}
2202 
2203 namespace Rose {
2204  std::string stringifyBinaryAnalysisPowerpcRegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
2205  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcRegisterClass();
2206 }
2207 
2208 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2209 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 481
2210 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2212  const char* PowerpcConditionRegisterAccessGranularity(int64_t);
2213 
2215  std::string PowerpcConditionRegisterAccessGranularity(int64_t, const std::string &strip);
2216 
2218  const std::vector<int64_t>& PowerpcConditionRegisterAccessGranularity();
2219 }}}
2220 
2221 namespace Rose {
2222  std::string stringifyBinaryAnalysisPowerpcConditionRegisterAccessGranularity(int64_t n, const char *strip=NULL, bool canonic=false);
2223  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcConditionRegisterAccessGranularity();
2224 }
2225 
2226 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2227 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 488
2228 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2230  const char* PowerpcSpecialPurposeRegister(int64_t);
2231 
2233  std::string PowerpcSpecialPurposeRegister(int64_t, const std::string &strip);
2234 
2236  const std::vector<int64_t>& PowerpcSpecialPurposeRegister();
2237 }}}
2238 
2239 namespace Rose {
2240  std::string stringifyBinaryAnalysisPowerpcSpecialPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
2241  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcSpecialPurposeRegister();
2242 }
2243 
2244 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2245 // /src/Rose/BinaryAnalysis/InstructionEnumsPowerpc.h line 499
2246 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2248  const char* PowerpcTimeBaseRegister(int64_t);
2249 
2251  std::string PowerpcTimeBaseRegister(int64_t, const std::string &strip);
2252 
2254  const std::vector<int64_t>& PowerpcTimeBaseRegister();
2255 }}}
2256 
2257 namespace Rose {
2258  std::string stringifyBinaryAnalysisPowerpcTimeBaseRegister(int64_t n, const char *strip=NULL, bool canonic=false);
2259  const std::vector<int64_t>& stringifyBinaryAnalysisPowerpcTimeBaseRegister();
2260 }
2261 
2262 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2263 // /src/Rose/BinaryAnalysis/MagicNumber.h line 21
2264 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace MagicNumber {
2266  const char* Mechanism(int64_t);
2267 
2269  std::string Mechanism(int64_t, const std::string &strip);
2270 
2272  const std::vector<int64_t>& Mechanism();
2273 }}}}
2274 
2275 namespace Rose {
2276  std::string stringifyBinaryAnalysisMagicNumberMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
2277  const std::vector<int64_t>& stringifyBinaryAnalysisMagicNumberMechanism();
2278 }
2279 
2280 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2281 // /src/Rose/BinaryAnalysis/Variables.h line 149
2282 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Variables { namespace StackVariable {
2284  const char* Purpose(int64_t);
2285 
2287  std::string Purpose(int64_t, const std::string &strip);
2288 
2290  const std::vector<int64_t>& Purpose();
2291 }}}}}
2292 
2293 namespace Rose {
2294  std::string stringifyBinaryAnalysisVariablesStackVariablePurpose(int64_t n, const char *strip=NULL, bool canonic=false);
2295  const std::vector<int64_t>& stringifyBinaryAnalysisVariablesStackVariablePurpose();
2296 }
2297 
2298 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2299 // /src/Rose/BinaryAnalysis/Variables.h line 389
2300 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Variables { namespace StackFrame {
2302  const char* Direction(int64_t);
2303 
2305  std::string Direction(int64_t, const std::string &strip);
2306 
2308  const std::vector<int64_t>& Direction();
2309 }}}}}
2310 
2311 namespace Rose {
2312  std::string stringifyBinaryAnalysisVariablesStackFrameDirection(int64_t n, const char *strip=NULL, bool canonic=false);
2313  const std::vector<int64_t>& stringifyBinaryAnalysisVariablesStackFrameDirection();
2314 }
2315 
2316 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2317 // /src/Rose/BinaryAnalysis/ConcreteLocation.h line 29
2318 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace ConcreteLocation {
2320  const char* Type(int64_t);
2321 
2323  std::string Type(int64_t, const std::string &strip);
2324 
2326  const std::vector<int64_t>& Type();
2327 }}}}
2328 
2329 namespace Rose {
2330  std::string stringifyBinaryAnalysisConcreteLocationType(int64_t n, const char *strip=NULL, bool canonic=false);
2331  const std::vector<int64_t>& stringifyBinaryAnalysisConcreteLocationType();
2332 }
2333 
2334 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2335 // /src/Rose/BinaryAnalysis/FunctionSimilarity.h line 73
2336 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
2338  const char* CValKind(int64_t);
2339 
2341  std::string CValKind(int64_t, const std::string &strip);
2342 
2344  const std::vector<int64_t>& CValKind();
2345 }}}}
2346 
2347 namespace Rose {
2348  std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(int64_t n, const char *strip=NULL, bool canonic=false);
2349  const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityCValKind();
2350 }
2351 
2352 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2353 // /src/Rose/BinaryAnalysis/FunctionSimilarity.h line 85
2354 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace FunctionSimilarity {
2356  const char* Statistic(int64_t);
2357 
2359  std::string Statistic(int64_t, const std::string &strip);
2360 
2362  const std::vector<int64_t>& Statistic();
2363 }}}}
2364 
2365 namespace Rose {
2366  std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(int64_t n, const char *strip=NULL, bool canonic=false);
2367  const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityStatistic();
2368 }
2369 
2370 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2371 // /src/Rose/BinaryAnalysis/SerialIo.h line 122
2372 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
2374  const char* Format(int64_t);
2375 
2377  std::string Format(int64_t, const std::string &strip);
2378 
2380  const std::vector<int64_t>& Format();
2381 }}}}
2382 
2383 namespace Rose {
2384  std::string stringifyBinaryAnalysisSerialIoFormat(int64_t n, const char *strip=NULL, bool canonic=false);
2385  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoFormat();
2386 }
2387 
2388 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2389 // /src/Rose/BinaryAnalysis/SerialIo.h line 133
2390 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace SerialIo {
2392  const char* Savable(int64_t);
2393 
2395  std::string Savable(int64_t, const std::string &strip);
2396 
2398  const std::vector<int64_t>& Savable();
2399 }}}}
2400 
2401 namespace Rose {
2402  std::string stringifyBinaryAnalysisSerialIoSavable(int64_t n, const char *strip=NULL, bool canonic=false);
2403  const std::vector<int64_t>& stringifyBinaryAnalysisSerialIoSavable();
2404 }
2405 
2406 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2407 // /src/Rose/BinaryAnalysis/CodeInserter.h line 14
2408 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Commit {
2410  const char* Boolean(int64_t);
2411 
2413  std::string Boolean(int64_t, const std::string &strip);
2414 
2416  const std::vector<int64_t>& Boolean();
2417 }}}}
2418 
2419 namespace Rose {
2420  std::string stringifyBinaryAnalysisCommitBoolean(int64_t n, const char *strip=NULL, bool canonic=false);
2421  const std::vector<int64_t>& stringifyBinaryAnalysisCommitBoolean();
2422 }
2423 
2424 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2425 // /src/Rose/BinaryAnalysis/CodeInserter.h line 24
2426 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
2428  const char* AggregationDirection(int64_t);
2429 
2431  std::string AggregationDirection(int64_t, const std::string &strip);
2432 
2434  const std::vector<int64_t>& AggregationDirection();
2435 }}}}
2436 
2437 namespace Rose {
2438  std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(int64_t n, const char *strip=NULL, bool canonic=false);
2439  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterAggregationDirection();
2440 }
2441 
2442 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2443 // /src/Rose/BinaryAnalysis/CodeInserter.h line 30
2444 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
2446  const char* NopPadding(int64_t);
2447 
2449  std::string NopPadding(int64_t, const std::string &strip);
2450 
2452  const std::vector<int64_t>& NopPadding();
2453 }}}}
2454 
2455 namespace Rose {
2456  std::string stringifyBinaryAnalysisCodeInserterNopPadding(int64_t n, const char *strip=NULL, bool canonic=false);
2457  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterNopPadding();
2458 }
2459 
2460 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2461 // /src/Rose/BinaryAnalysis/CodeInserter.h line 54
2462 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CodeInserter {
2464  const char* RelocType(int64_t);
2465 
2467  std::string RelocType(int64_t, const std::string &strip);
2468 
2470  const std::vector<int64_t>& RelocType();
2471 }}}}
2472 
2473 namespace Rose {
2474  std::string stringifyBinaryAnalysisCodeInserterRelocType(int64_t n, const char *strip=NULL, bool canonic=false);
2475  const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterRelocType();
2476 }
2477 
2478 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2479 // /src/Rose/BinaryAnalysis/BinaryLoader.h line 63
2480 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
2482  const char* MappingContribution(int64_t);
2483 
2485  std::string MappingContribution(int64_t, const std::string &strip);
2486 
2488  const std::vector<int64_t>& MappingContribution();
2489 }}}}
2490 
2491 namespace Rose {
2492  std::string stringifyBinaryAnalysisBinaryLoaderMappingContribution(int64_t n, const char *strip=NULL, bool canonic=false);
2493  const std::vector<int64_t>& stringifyBinaryAnalysisBinaryLoaderMappingContribution();
2494 }
2495 
2496 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2497 // /src/Rose/BinaryAnalysis/BinaryLoader.h line 71
2498 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace BinaryLoader {
2500  const char* ConflictResolution(int64_t);
2501 
2503  std::string ConflictResolution(int64_t, const std::string &strip);
2504 
2506  const std::vector<int64_t>& ConflictResolution();
2507 }}}}
2508 
2509 namespace Rose {
2510  std::string stringifyBinaryAnalysisBinaryLoaderConflictResolution(int64_t n, const char *strip=NULL, bool canonic=false);
2511  const std::vector<int64_t>& stringifyBinaryAnalysisBinaryLoaderConflictResolution();
2512 }
2513 
2514 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2515 // /src/Rose/BinaryAnalysis/Disassembler/Aarch64.h line 46
2516 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Aarch64 {
2518  const char* Mode(int64_t);
2519 
2521  std::string Mode(int64_t, const std::string &strip);
2522 
2524  const std::vector<int64_t>& Mode();
2525 }}}}}
2526 
2527 namespace Rose {
2528  std::string stringifyBinaryAnalysisDisassemblerAarch64Mode(int64_t n, const char *strip=NULL, bool canonic=false);
2529  const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerAarch64Mode();
2530 }
2531 
2532 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2533 // /src/Rose/BinaryAnalysis/Disassembler/Aarch32.h line 22
2534 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Aarch32 {
2536  const char* Mode(int64_t);
2537 
2539  std::string Mode(int64_t, const std::string &strip);
2540 
2542  const std::vector<int64_t>& Mode();
2543 }}}}}
2544 
2545 namespace Rose {
2546  std::string stringifyBinaryAnalysisDisassemblerAarch32Mode(int64_t n, const char *strip=NULL, bool canonic=false);
2547  const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerAarch32Mode();
2548 }
2549 
2550 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2551 // /src/Rose/BinaryAnalysis/Disassembler/Mips.h line 47
2552 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace Mips { namespace Decoder {
2554  const char* Architecture(int64_t);
2555 
2557  std::string Architecture(int64_t, const std::string &strip);
2558 
2560  const std::vector<int64_t>& Architecture();
2561 }}}}}}
2562 
2563 namespace Rose {
2564  std::string stringifyBinaryAnalysisDisassemblerMipsDecoderArchitecture(int64_t n, const char *strip=NULL, bool canonic=false);
2565  const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerMipsDecoderArchitecture();
2566 }
2567 
2568 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2569 // /src/Rose/BinaryAnalysis/Disassembler/X86.h line 155
2570 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace X86 {
2572  const char* RegisterMode(int64_t);
2573 
2575  std::string RegisterMode(int64_t, const std::string &strip);
2576 
2578  const std::vector<int64_t>& RegisterMode();
2579 }}}}}
2580 
2581 namespace Rose {
2582  std::string stringifyBinaryAnalysisDisassemblerX86RegisterMode(int64_t n, const char *strip=NULL, bool canonic=false);
2583  const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerX86RegisterMode();
2584 }
2585 
2586 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2587 // /src/Rose/BinaryAnalysis/Disassembler/X86.h line 160
2588 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Disassembler { namespace X86 {
2590  const char* MMPrefix(int64_t);
2591 
2593  std::string MMPrefix(int64_t, const std::string &strip);
2594 
2596  const std::vector<int64_t>& MMPrefix();
2597 }}}}}
2598 
2599 namespace Rose {
2600  std::string stringifyBinaryAnalysisDisassemblerX86MMPrefix(int64_t n, const char *strip=NULL, bool canonic=false);
2601  const std::vector<int64_t>& stringifyBinaryAnalysisDisassemblerX86MMPrefix();
2602 }
2603 
2604 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2605 // /src/Rose/BinaryAnalysis/CallingConvention.h line 60
2606 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
2608  const char* StackParameterOrder(int64_t);
2609 
2611  std::string StackParameterOrder(int64_t, const std::string &strip);
2612 
2614  const std::vector<int64_t>& StackParameterOrder();
2615 }}}}
2616 
2617 namespace Rose {
2618  std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(int64_t n, const char *strip=NULL, bool canonic=false);
2619  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackParameterOrder();
2620 }
2621 
2622 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2623 // /src/Rose/BinaryAnalysis/CallingConvention.h line 67
2624 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
2626  const char* StackDirection(int64_t);
2627 
2629  std::string StackDirection(int64_t, const std::string &strip);
2630 
2632  const std::vector<int64_t>& StackDirection();
2633 }}}}
2634 
2635 namespace Rose {
2636  std::string stringifyBinaryAnalysisCallingConventionStackDirection(int64_t n, const char *strip=NULL, bool canonic=false);
2637  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackDirection();
2638 }
2639 
2640 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2641 // /src/Rose/BinaryAnalysis/CallingConvention.h line 73
2642 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace CallingConvention {
2644  const char* StackCleanup(int64_t);
2645 
2647  std::string StackCleanup(int64_t, const std::string &strip);
2648 
2650  const std::vector<int64_t>& StackCleanup();
2651 }}}}
2652 
2653 namespace Rose {
2654  std::string stringifyBinaryAnalysisCallingConventionStackCleanup(int64_t n, const char *strip=NULL, bool canonic=false);
2655  const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackCleanup();
2656 }
2657 
2658 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2659 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 34
2660 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2662  const char* Aarch64Exception(int64_t);
2663 
2665  std::string Aarch64Exception(int64_t, const std::string &strip);
2666 
2668  const std::vector<int64_t>& Aarch64Exception();
2669 }}}
2670 
2671 namespace Rose {
2672  std::string stringifyBinaryAnalysisAarch64Exception(int64_t n, const char *strip=NULL, bool canonic=false);
2673  const std::vector<int64_t>& stringifyBinaryAnalysisAarch64Exception();
2674 }
2675 
2676 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2677 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 39
2678 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2680  const char* Aarch64RegisterClass(int64_t);
2681 
2683  std::string Aarch64RegisterClass(int64_t, const std::string &strip);
2684 
2686  const std::vector<int64_t>& Aarch64RegisterClass();
2687 }}}
2688 
2689 namespace Rose {
2690  std::string stringifyBinaryAnalysisAarch64RegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
2691  const std::vector<int64_t>& stringifyBinaryAnalysisAarch64RegisterClass();
2692 }
2693 
2694 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2695 // /src/Rose/BinaryAnalysis/InstructionEnumsAarch64.h line 54
2696 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2698  const char* Aarch64SystemRegisters(int64_t);
2699 
2701  std::string Aarch64SystemRegisters(int64_t, const std::string &strip);
2702 
2704  const std::vector<int64_t>& Aarch64SystemRegisters();
2705 }}}
2706 
2707 namespace Rose {
2708  std::string stringifyBinaryAnalysisAarch64SystemRegisters(int64_t n, const char *strip=NULL, bool canonic=false);
2709  const std::vector<int64_t>& stringifyBinaryAnalysisAarch64SystemRegisters();
2710 }
2711 
2712 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2713 // /src/Rose/BinaryAnalysis/InstructionEnumsJvm.h line 29
2714 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2716  const char* JvmInstructionKind(int64_t);
2717 
2719  std::string JvmInstructionKind(int64_t, const std::string &strip);
2720 
2722  const std::vector<int64_t>& JvmInstructionKind();
2723 }}}
2724 
2725 namespace Rose {
2726  std::string stringifyBinaryAnalysisJvmInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
2727  const std::vector<int64_t>& stringifyBinaryAnalysisJvmInstructionKind();
2728 }
2729 
2730 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2731 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 13
2732 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2734  const char* X86InstructionSize(int64_t);
2735 
2737  std::string X86InstructionSize(int64_t, const std::string &strip);
2738 
2740  const std::vector<int64_t>& X86InstructionSize();
2741 }}}
2742 
2743 namespace Rose {
2744  std::string stringifyBinaryAnalysisX86InstructionSize(int64_t n, const char *strip=NULL, bool canonic=false);
2745  const std::vector<int64_t>& stringifyBinaryAnalysisX86InstructionSize();
2746 }
2747 
2748 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2749 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 21
2750 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2752  const char* X86RegisterClass(int64_t);
2753 
2755  std::string X86RegisterClass(int64_t, const std::string &strip);
2756 
2758  const std::vector<int64_t>& X86RegisterClass();
2759 }}}
2760 
2761 namespace Rose {
2762  std::string stringifyBinaryAnalysisX86RegisterClass(int64_t n, const char *strip=NULL, bool canonic=false);
2763  const std::vector<int64_t>& stringifyBinaryAnalysisX86RegisterClass();
2764 }
2765 
2766 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2767 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 34
2768 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2770  const char* X86SegmentRegister(int64_t);
2771 
2773  std::string X86SegmentRegister(int64_t, const std::string &strip);
2774 
2776  const std::vector<int64_t>& X86SegmentRegister();
2777 }}}
2778 
2779 namespace Rose {
2780  std::string stringifyBinaryAnalysisX86SegmentRegister(int64_t n, const char *strip=NULL, bool canonic=false);
2781  const std::vector<int64_t>& stringifyBinaryAnalysisX86SegmentRegister();
2782 }
2783 
2784 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2785 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 45
2786 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2788  const char* X86GeneralPurposeRegister(int64_t);
2789 
2791  std::string X86GeneralPurposeRegister(int64_t, const std::string &strip);
2792 
2794  const std::vector<int64_t>& X86GeneralPurposeRegister();
2795 }}}
2796 
2797 namespace Rose {
2798  std::string stringifyBinaryAnalysisX86GeneralPurposeRegister(int64_t n, const char *strip=NULL, bool canonic=false);
2799  const std::vector<int64_t>& stringifyBinaryAnalysisX86GeneralPurposeRegister();
2800 }
2801 
2802 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2803 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 65
2804 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2806  const char* X86StRegister(int64_t);
2807 
2809  std::string X86StRegister(int64_t, const std::string &strip);
2810 
2812  const std::vector<int64_t>& X86StRegister();
2813 }}}
2814 
2815 namespace Rose {
2816  std::string stringifyBinaryAnalysisX86StRegister(int64_t n, const char *strip=NULL, bool canonic=false);
2817  const std::vector<int64_t>& stringifyBinaryAnalysisX86StRegister();
2818 }
2819 
2820 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2821 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 78
2822 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2824  const char* X86Flags(int64_t);
2825 
2827  std::string X86Flags(int64_t, const std::string &strip);
2828 
2830  const std::vector<int64_t>& X86Flags();
2831 }}}
2832 
2833 namespace Rose {
2834  std::string stringifyBinaryAnalysisX86Flags(int64_t n, const char *strip=NULL, bool canonic=false);
2835  const std::vector<int64_t>& stringifyBinaryAnalysisX86Flags();
2836 }
2837 
2838 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2839 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 87
2840 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2842  const char* X86Flag(int64_t);
2843 
2845  std::string X86Flag(int64_t, const std::string &strip);
2846 
2848  const std::vector<int64_t>& X86Flag();
2849 }}}
2850 
2851 namespace Rose {
2852  std::string stringifyBinaryAnalysisX86Flag(int64_t n, const char *strip=NULL, bool canonic=false);
2853  const std::vector<int64_t>& stringifyBinaryAnalysisX86Flag();
2854 }
2855 
2856 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2857 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 108
2858 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2860  const char* X86BranchPrediction(int64_t);
2861 
2863  std::string X86BranchPrediction(int64_t, const std::string &strip);
2864 
2866  const std::vector<int64_t>& X86BranchPrediction();
2867 }}}
2868 
2869 namespace Rose {
2870  std::string stringifyBinaryAnalysisX86BranchPrediction(int64_t n, const char *strip=NULL, bool canonic=false);
2871  const std::vector<int64_t>& stringifyBinaryAnalysisX86BranchPrediction();
2872 }
2873 
2874 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2875 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 116
2876 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2878  const char* X86RepeatPrefix(int64_t);
2879 
2881  std::string X86RepeatPrefix(int64_t, const std::string &strip);
2882 
2884  const std::vector<int64_t>& X86RepeatPrefix();
2885 }}}
2886 
2887 namespace Rose {
2888  std::string stringifyBinaryAnalysisX86RepeatPrefix(int64_t n, const char *strip=NULL, bool canonic=false);
2889  const std::vector<int64_t>& stringifyBinaryAnalysisX86RepeatPrefix();
2890 }
2891 
2892 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2893 // /src/Rose/BinaryAnalysis/InstructionEnumsX86.h line 125
2894 namespace stringify { namespace Rose { namespace BinaryAnalysis {
2896  const char* X86Exception(int64_t);
2897 
2899  std::string X86Exception(int64_t, const std::string &strip);
2900 
2902  const std::vector<int64_t>& X86Exception();
2903 }}}
2904 
2905 namespace Rose {
2906  std::string stringifyBinaryAnalysisX86Exception(int64_t n, const char *strip=NULL, bool canonic=false);
2907  const std::vector<int64_t>& stringifyBinaryAnalysisX86Exception();
2908 }
2909 
2910 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2911 // /src/Rose/BinaryAnalysis/TaintedFlow.h line 24
2912 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
2914  const char* Taintedness(int64_t);
2915 
2917  std::string Taintedness(int64_t, const std::string &strip);
2918 
2920  const std::vector<int64_t>& Taintedness();
2921 }}}}
2922 
2923 namespace Rose {
2924  std::string stringifyBinaryAnalysisTaintedFlowTaintedness(int64_t n, const char *strip=NULL, bool canonic=false);
2925  const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowTaintedness();
2926 }
2927 
2928 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2929 // /src/Rose/BinaryAnalysis/TaintedFlow.h line 31
2930 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace TaintedFlow {
2932  const char* Approximation(int64_t);
2933 
2935  std::string Approximation(int64_t, const std::string &strip);
2936 
2938  const std::vector<int64_t>& Approximation();
2939 }}}}
2940 
2941 namespace Rose {
2942  std::string stringifyBinaryAnalysisTaintedFlowApproximation(int64_t n, const char *strip=NULL, bool canonic=false);
2943  const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowApproximation();
2944 }
2945 
2946 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2947 // /src/Rose/BinaryAnalysis/Reachability.h line 25
2948 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace Reachability {
2950  const char* Reason(int64_t);
2951 
2953  std::string Reason(int64_t, const std::string &strip);
2954 
2956  const std::vector<int64_t>& Reason();
2957 }}}}
2958 
2959 namespace Rose {
2960  std::string stringifyBinaryAnalysisReachabilityReason(int64_t n, const char *strip=NULL, bool canonic=false);
2961  const std::vector<int64_t>& stringifyBinaryAnalysisReachabilityReason();
2962 }
2963 
2964 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2965 // /src/Rose/Color.h line 22
2966 namespace stringify { namespace Rose { namespace Color { namespace Enabled {
2968  const char* Flag(int64_t);
2969 
2971  std::string Flag(int64_t, const std::string &strip);
2972 
2974  const std::vector<int64_t>& Flag();
2975 }}}}
2976 
2977 namespace Rose {
2978  std::string stringifyColorEnabledFlag(int64_t n, const char *strip=NULL, bool canonic=false);
2979  const std::vector<int64_t>& stringifyColorEnabledFlag();
2980 }
2981 
2982 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
2983 // /src/Rose/Color.h line 33
2984 namespace stringify { namespace Rose { namespace Color { namespace Theme {
2986  const char* Flag(int64_t);
2987 
2989  std::string Flag(int64_t, const std::string &strip);
2990 
2992  const std::vector<int64_t>& Flag();
2993 }}}}
2994 
2995 namespace Rose {
2996  std::string stringifyColorThemeFlag(int64_t n, const char *strip=NULL, bool canonic=false);
2997  const std::vector<int64_t>& stringifyColorThemeFlag();
2998 }
2999 
3000 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3001 // /src/Rose/Color.h line 53
3002 namespace stringify { namespace Rose { namespace Color { namespace Layer {
3004  const char* Flag(int64_t);
3005 
3007  std::string Flag(int64_t, const std::string &strip);
3008 
3010  const std::vector<int64_t>& Flag();
3011 }}}}
3012 
3013 namespace Rose {
3014  std::string stringifyColorLayerFlag(int64_t n, const char *strip=NULL, bool canonic=false);
3015  const std::vector<int64_t>& stringifyColorLayerFlag();
3016 }
3017 
3018 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3019 // /src/Rose/Color.h line 359
3020 namespace stringify { namespace Rose { namespace Color {
3022  const char* AnsiColor(int64_t);
3023 
3025  std::string AnsiColor(int64_t, const std::string &strip);
3026 
3028  const std::vector<int64_t>& AnsiColor();
3029 }}}
3030 
3031 namespace Rose {
3032  std::string stringifyColorAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
3033  const std::vector<int64_t>& stringifyColorAnsiColor();
3034 }
3035 
3036 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3037 // /src/Rose/Yaml.h line 154
3038 namespace stringify { namespace Rose { namespace Yaml { namespace Exception {
3040  const char* eType(int64_t);
3041 
3043  std::string eType(int64_t, const std::string &strip);
3044 
3046  const std::vector<int64_t>& eType();
3047 }}}}
3048 
3049 namespace Rose {
3050  std::string stringifyYamlException_eType(int64_t n, const char *strip=NULL, bool canonic=false);
3051  const std::vector<int64_t>& stringifyYamlException_eType();
3052 }
3053 
3054 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3055 // /src/Rose/Yaml.h line 259
3056 namespace stringify { namespace Rose { namespace Yaml { namespace Iterator {
3058  const char* eType(int64_t);
3059 
3061  std::string eType(int64_t, const std::string &strip);
3062 
3064  const std::vector<int64_t>& eType();
3065 }}}}
3066 
3067 namespace Rose {
3068  std::string stringifyYamlIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
3069  const std::vector<int64_t>& stringifyYamlIterator_eType();
3070 }
3071 
3072 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3073 // /src/Rose/Yaml.h line 316
3074 namespace stringify { namespace Rose { namespace Yaml { namespace ConstIterator {
3076  const char* eType(int64_t);
3077 
3079  std::string eType(int64_t, const std::string &strip);
3080 
3082  const std::vector<int64_t>& eType();
3083 }}}}
3084 
3085 namespace Rose {
3086  std::string stringifyYamlConstIterator_eType(int64_t n, const char *strip=NULL, bool canonic=false);
3087  const std::vector<int64_t>& stringifyYamlConstIterator_eType();
3088 }
3089 
3090 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3091 // /src/Rose/Yaml.h line 333
3092 namespace stringify { namespace Rose { namespace Yaml { namespace Node {
3094  const char* eType(int64_t);
3095 
3097  std::string eType(int64_t, const std::string &strip);
3098 
3100  const std::vector<int64_t>& eType();
3101 }}}}
3102 
3103 namespace Rose {
3104  std::string stringifyYamlNode_eType(int64_t n, const char *strip=NULL, bool canonic=false);
3105  const std::vector<int64_t>& stringifyYamlNode_eType();
3106 }
3107 
3108 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3109 // /src/Rose/CodeGen/Object.h line 11
3110 namespace stringify { namespace Rose { namespace CodeGen {
3112  const char* Object(int64_t);
3113 
3115  std::string Object(int64_t, const std::string &strip);
3116 
3118  const std::vector<int64_t>& Object();
3119 }}}
3120 
3121 namespace Rose {
3122  std::string stringifyCodeGenObject(int64_t n, const char *strip=NULL, bool canonic=false);
3123  const std::vector<int64_t>& stringifyCodeGenObject();
3124 }
3125 
3126 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3127 // /src/Rose/Yaml.C line 1216
3128 namespace stringify { namespace Rose { namespace Yaml { namespace ReaderLine {
3130  const char* eFlag(int64_t);
3131 
3133  std::string eFlag(int64_t, const std::string &strip);
3134 
3136  const std::vector<int64_t>& eFlag();
3137 }}}}
3138 
3139 namespace Rose {
3140  std::string stringifyYamlReaderLine_eFlag(int64_t n, const char *strip=NULL, bool canonic=false);
3141  const std::vector<int64_t>& stringifyYamlReaderLine_eFlag();
3142 }
3143 
3144 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3145 // /src/Rose/CommandLine/Parser.C line 31
3146 namespace stringify { namespace Rose { namespace CommandLine { namespace FailedAssertionBehaviorAdjuster {
3148  const char* Behavior(int64_t);
3149 
3151  std::string Behavior(int64_t, const std::string &strip);
3152 
3154  const std::vector<int64_t>& Behavior();
3155 }}}}
3156 
3157 namespace Rose {
3158  std::string stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior(int64_t n, const char *strip=NULL, bool canonic=false);
3159  const std::vector<int64_t>& stringifyCommandLineFailedAssertionBehaviorAdjusterBehavior();
3160 }
3161 
3162 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3163 // /src/Rose/CommandLine/SuffixMultiplierParser.h line 36
3164 namespace stringify { namespace Rose { namespace CommandLine { namespace SuffixMultiplierParser {
3166  const char* Preferred(int64_t);
3167 
3169  std::string Preferred(int64_t, const std::string &strip);
3170 
3172  const std::vector<int64_t>& Preferred();
3173 }}}}
3174 
3175 namespace Rose {
3176  std::string stringifyCommandLineSuffixMultiplierParserPreferred(int64_t n, const char *strip=NULL, bool canonic=false);
3177  const std::vector<int64_t>& stringifyCommandLineSuffixMultiplierParserPreferred();
3178 }
3179 
3180 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3181 // /src/ROSETTA/src/AstNodeClass.h line 100
3182 namespace stringify { namespace AstNodeClass {
3184  const char* locationInTree(int64_t);
3185 
3187  std::string locationInTree(int64_t, const std::string &strip);
3188 
3190  const std::vector<int64_t>& locationInTree();
3191 }}
3192 
3193 namespace Rose {
3194  std::string stringifyAstNodeClass_locationInTree(int64_t n, const char *strip=NULL, bool canonic=false);
3195  const std::vector<int64_t>& stringifyAstNodeClass_locationInTree();
3196 }
3197 
3198 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3199 // /src/ROSETTA/src/AstNodeClass.h line 106
3200 namespace stringify { namespace AstNodeClass {
3202  const char* includeExcludeMechanism(int64_t);
3203 
3205  std::string includeExcludeMechanism(int64_t, const std::string &strip);
3206 
3208  const std::vector<int64_t>& includeExcludeMechanism();
3209 }}
3210 
3211 namespace Rose {
3212  std::string stringifyAstNodeClass_includeExcludeMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
3213  const std::vector<int64_t>& stringifyAstNodeClass_includeExcludeMechanism();
3214 }
3215 
3216 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3217 // /src/ROSETTA/src/AstNodeClass.h line 319
3218 namespace stringify { namespace AstNodeClass {
3220  const char* TypeEvaluation(int64_t);
3221 
3223  std::string TypeEvaluation(int64_t, const std::string &strip);
3224 
3226  const std::vector<int64_t>& TypeEvaluation();
3227 }}
3228 
3229 namespace Rose {
3230  std::string stringifyAstNodeClassTypeEvaluation(int64_t n, const char *strip=NULL, bool canonic=false);
3231  const std::vector<int64_t>& stringifyAstNodeClassTypeEvaluation();
3232 }
3233 
3234 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3235 // /src/ROSETTA/src/binaryInstruction.C line 950
3236 namespace stringify { namespace SgAsmNullInstruction {
3238  const char* Kind(int64_t);
3239 
3241  std::string Kind(int64_t, const std::string &strip);
3242 
3244  const std::vector<int64_t>& Kind();
3245 }}
3246 
3247 namespace Rose {
3248  std::string stringifySgAsmNullInstructionKind(int64_t n, const char *strip=NULL, bool canonic=false);
3249  const std::vector<int64_t>& stringifySgAsmNullInstructionKind();
3250 }
3251 
3252 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3253 // /src/ROSETTA/src/binaryInstruction.C line 3502
3254 namespace stringify { namespace SgAsmRiscOperation {
3256  const char* RiscOperator(int64_t);
3257 
3259  std::string RiscOperator(int64_t, const std::string &strip);
3260 
3262  const std::vector<int64_t>& RiscOperator();
3263 }}
3264 
3265 namespace Rose {
3266  std::string stringifySgAsmRiscOperationRiscOperator(int64_t n, const char *strip=NULL, bool canonic=false);
3267  const std::vector<int64_t>& stringifySgAsmRiscOperationRiscOperator();
3268 }
3269 
3270 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3271 // /src/ROSETTA/src/binaryInstruction.C line 3833
3272 namespace stringify { namespace SgAsmFloatType {
3274  const char* Flag(int64_t);
3275 
3277  std::string Flag(int64_t, const std::string &strip);
3278 
3280  const std::vector<int64_t>& Flag();
3281 }}
3282 
3283 namespace Rose {
3284  std::string stringifySgAsmFloatTypeFlag(int64_t n, const char *strip=NULL, bool canonic=false);
3285  const std::vector<int64_t>& stringifySgAsmFloatTypeFlag();
3286 }
3287 
3288 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3289 // /src/ROSETTA/src/binaryInstruction.C line 4351
3290 namespace stringify { namespace SgAsmFunction {
3292  const char* MayReturn(int64_t);
3293 
3295  std::string MayReturn(int64_t, const std::string &strip);
3296 
3298  const std::vector<int64_t>& MayReturn();
3299 }}
3300 
3301 namespace Rose {
3302  std::string stringifySgAsmFunctionMayReturn(int64_t n, const char *strip=NULL, bool canonic=false);
3303  const std::vector<int64_t>& stringifySgAsmFunctionMayReturn();
3304 }
3305 
3306 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3307 // /src/ROSETTA/src/binaryInstruction.C line 4361
3308 namespace stringify { namespace SgAsmFunction {
3310  const char* FunctionReason(int64_t);
3311 
3313  std::string FunctionReason(int64_t, const std::string &strip);
3314 
3316  const std::vector<int64_t>& FunctionReason();
3317 }}
3318 
3319 namespace Rose {
3320  std::string stringifySgAsmFunctionFunctionReason(int64_t n, const char *strip=NULL, bool canonic=false);
3321  const std::vector<int64_t>& stringifySgAsmFunctionFunctionReason();
3322 }
3323 
3324 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3325 // /src/ROSETTA/src/binaryInstruction.C line 4517
3326 namespace stringify { namespace SgAsmFunction {
3328  const char* function_kind_enum(int64_t);
3329 
3331  std::string function_kind_enum(int64_t, const std::string &strip);
3332 
3334  const std::vector<int64_t>& function_kind_enum();
3335 }}
3336 
3337 namespace Rose {
3338  std::string stringifySgAsmFunction_function_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
3339  const std::vector<int64_t>& stringifySgAsmFunction_function_kind_enum();
3340 }
3341 
3342 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3343 // /src/ROSETTA/src/binaryInstruction.C line 4747
3344 namespace stringify { namespace SgAsmBlock {
3346  const char* Reason(int64_t);
3347 
3349  std::string Reason(int64_t, const std::string &strip);
3350 
3352  const std::vector<int64_t>& Reason();
3353 }}
3354 
3355 namespace Rose {
3356  std::string stringifySgAsmBlockReason(int64_t n, const char *strip=NULL, bool canonic=false);
3357  const std::vector<int64_t>& stringifySgAsmBlockReason();
3358 }
3359 
3360 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3361 // /src/ROSETTA/src/binaryInstruction.C line 5583
3362 namespace stringify { namespace SgAsmElfFileHeader {
3364  const char* ObjectType(int64_t);
3365 
3367  std::string ObjectType(int64_t, const std::string &strip);
3368 
3370  const std::vector<int64_t>& ObjectType();
3371 }}
3372 
3373 namespace Rose {
3374  std::string stringifySgAsmElfFileHeaderObjectType(int64_t n, const char *strip=NULL, bool canonic=false);
3375  const std::vector<int64_t>& stringifySgAsmElfFileHeaderObjectType();
3376 }
3377 
3378 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3379 // /src/ROSETTA/src/binaryInstruction.C line 6238
3380 namespace stringify { namespace SgAsmElfSectionTableEntry {
3382  const char* SectionType(int64_t);
3383 
3385  std::string SectionType(int64_t, const std::string &strip);
3386 
3388  const std::vector<int64_t>& SectionType();
3389 }}
3390 
3391 namespace Rose {
3392  std::string stringifySgAsmElfSectionTableEntrySectionType(int64_t n, const char *strip=NULL, bool canonic=false);
3393  const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionType();
3394 }
3395 
3396 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3397 // /src/ROSETTA/src/binaryInstruction.C line 6265
3398 namespace stringify { namespace SgAsmElfSectionTableEntry {
3400  const char* SectionFlags(int64_t);
3401 
3403  std::string SectionFlags(int64_t, const std::string &strip);
3404 
3406  const std::vector<int64_t>& SectionFlags();
3407 }}
3408 
3409 namespace Rose {
3410  std::string stringifySgAsmElfSectionTableEntrySectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
3411  const std::vector<int64_t>& stringifySgAsmElfSectionTableEntrySectionFlags();
3412 }
3413 
3414 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3415 // /src/ROSETTA/src/binaryInstruction.C line 6667
3416 namespace stringify { namespace SgAsmElfSegmentTableEntry {
3418  const char* SegmentType(int64_t);
3419 
3421  std::string SegmentType(int64_t, const std::string &strip);
3422 
3424  const std::vector<int64_t>& SegmentType();
3425 }}
3426 
3427 namespace Rose {
3428  std::string stringifySgAsmElfSegmentTableEntrySegmentType(int64_t n, const char *strip=NULL, bool canonic=false);
3429  const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentType();
3430 }
3431 
3432 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3433 // /src/ROSETTA/src/binaryInstruction.C line 6695
3434 namespace stringify { namespace SgAsmElfSegmentTableEntry {
3436  const char* SegmentFlags(int64_t);
3437 
3439  std::string SegmentFlags(int64_t, const std::string &strip);
3440 
3442  const std::vector<int64_t>& SegmentFlags();
3443 }}
3444 
3445 namespace Rose {
3446  std::string stringifySgAsmElfSegmentTableEntrySegmentFlags(int64_t n, const char *strip=NULL, bool canonic=false);
3447  const std::vector<int64_t>& stringifySgAsmElfSegmentTableEntrySegmentFlags();
3448 }
3449 
3450 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3451 // /src/ROSETTA/src/binaryInstruction.C line 7041
3452 namespace stringify { namespace SgAsmElfSymbol {
3454  const char* ElfSymBinding(int64_t);
3455 
3457  std::string ElfSymBinding(int64_t, const std::string &strip);
3458 
3460  const std::vector<int64_t>& ElfSymBinding();
3461 }}
3462 
3463 namespace Rose {
3464  std::string stringifySgAsmElfSymbolElfSymBinding(int64_t n, const char *strip=NULL, bool canonic=false);
3465  const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymBinding();
3466 }
3467 
3468 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3469 // /src/ROSETTA/src/binaryInstruction.C line 7047
3470 namespace stringify { namespace SgAsmElfSymbol {
3472  const char* ElfSymType(int64_t);
3473 
3475  std::string ElfSymType(int64_t, const std::string &strip);
3476 
3478  const std::vector<int64_t>& ElfSymType();
3479 }}
3480 
3481 namespace Rose {
3482  std::string stringifySgAsmElfSymbolElfSymType(int64_t n, const char *strip=NULL, bool canonic=false);
3483  const std::vector<int64_t>& stringifySgAsmElfSymbolElfSymType();
3484 }
3485 
3486 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3487 // /src/ROSETTA/src/binaryInstruction.C line 8449
3488 namespace stringify { namespace SgAsmElfRelocEntry {
3490  const char* RelocType(int64_t);
3491 
3493  std::string RelocType(int64_t, const std::string &strip);
3494 
3496  const std::vector<int64_t>& RelocType();
3497 }}
3498 
3499 namespace Rose {
3500  std::string stringifySgAsmElfRelocEntryRelocType(int64_t n, const char *strip=NULL, bool canonic=false);
3501  const std::vector<int64_t>& stringifySgAsmElfRelocEntryRelocType();
3502 }
3503 
3504 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3505 // /src/ROSETTA/src/binaryInstruction.C line 8806
3506 namespace stringify { namespace SgAsmElfDynamicEntry {
3508  const char* EntryType(int64_t);
3509 
3511  std::string EntryType(int64_t, const std::string &strip);
3512 
3514  const std::vector<int64_t>& EntryType();
3515 }}
3516 
3517 namespace Rose {
3518  std::string stringifySgAsmElfDynamicEntryEntryType(int64_t n, const char *strip=NULL, bool canonic=false);
3519  const std::vector<int64_t>& stringifySgAsmElfDynamicEntryEntryType();
3520 }
3521 
3522 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3523 // /src/ROSETTA/src/binaryInstruction.C line 10406
3524 namespace stringify { namespace SgAsmJvmConstantPoolEntry {
3526  const char* Kind(int64_t);
3527 
3529  std::string Kind(int64_t, const std::string &strip);
3530 
3532  const std::vector<int64_t>& Kind();
3533 }}
3534 
3535 namespace Rose {
3536  std::string stringifySgAsmJvmConstantPoolEntryKind(int64_t n, const char *strip=NULL, bool canonic=false);
3537  const std::vector<int64_t>& stringifySgAsmJvmConstantPoolEntryKind();
3538 }
3539 
3540 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3541 // /src/ROSETTA/src/binaryInstruction.C line 13834
3542 namespace stringify { namespace SgAsmPEFileHeader {
3544  const char* HeaderFlags(int64_t);
3545 
3547  std::string HeaderFlags(int64_t, const std::string &strip);
3548 
3550  const std::vector<int64_t>& HeaderFlags();
3551 }}
3552 
3553 namespace Rose {
3554  std::string stringifySgAsmPEFileHeaderHeaderFlags(int64_t n, const char *strip=NULL, bool canonic=false);
3555  const std::vector<int64_t>& stringifySgAsmPEFileHeaderHeaderFlags();
3556 }
3557 
3558 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3559 // /src/ROSETTA/src/binaryInstruction.C line 13843
3560 namespace stringify { namespace SgAsmPEFileHeader {
3562  const char* Subsystem(int64_t);
3563 
3565  std::string Subsystem(int64_t, const std::string &strip);
3566 
3568  const std::vector<int64_t>& Subsystem();
3569 }}
3570 
3571 namespace Rose {
3572  std::string stringifySgAsmPEFileHeaderSubsystem(int64_t n, const char *strip=NULL, bool canonic=false);
3573  const std::vector<int64_t>& stringifySgAsmPEFileHeaderSubsystem();
3574 }
3575 
3576 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3577 // /src/ROSETTA/src/binaryInstruction.C line 13853
3578 namespace stringify { namespace SgAsmPEFileHeader {
3580  const char* DLLFlags(int64_t);
3581 
3583  std::string DLLFlags(int64_t, const std::string &strip);
3584 
3586  const std::vector<int64_t>& DLLFlags();
3587 }}
3588 
3589 namespace Rose {
3590  std::string stringifySgAsmPEFileHeaderDLLFlags(int64_t n, const char *strip=NULL, bool canonic=false);
3591  const std::vector<int64_t>& stringifySgAsmPEFileHeaderDLLFlags();
3592 }
3593 
3594 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3595 // /src/ROSETTA/src/binaryInstruction.C line 13862
3596 namespace stringify { namespace SgAsmPEFileHeader {
3598  const char* PairPurpose(int64_t);
3599 
3601  std::string PairPurpose(int64_t, const std::string &strip);
3602 
3604  const std::vector<int64_t>& PairPurpose();
3605 }}
3606 
3607 namespace Rose {
3608  std::string stringifySgAsmPEFileHeaderPairPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
3609  const std::vector<int64_t>& stringifySgAsmPEFileHeaderPairPurpose();
3610 }
3611 
3612 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3613 // /src/ROSETTA/src/binaryInstruction.C line 15671
3614 namespace stringify { namespace SgAsmPESectionTableEntry {
3616  const char* PESectionFlags(int64_t);
3617 
3619  std::string PESectionFlags(int64_t, const std::string &strip);
3620 
3622  const std::vector<int64_t>& PESectionFlags();
3623 }}
3624 
3625 namespace Rose {
3626  std::string stringifySgAsmPESectionTableEntryPESectionFlags(int64_t n, const char *strip=NULL, bool canonic=false);
3627  const std::vector<int64_t>& stringifySgAsmPESectionTableEntryPESectionFlags();
3628 }
3629 
3630 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3631 // /src/ROSETTA/src/binaryInstruction.C line 17704
3632 namespace stringify { namespace SgAsmGenericSymbol {
3634  const char* SymbolDefState(int64_t);
3635 
3637  std::string SymbolDefState(int64_t, const std::string &strip);
3638 
3640  const std::vector<int64_t>& SymbolDefState();
3641 }}
3642 
3643 namespace Rose {
3644  std::string stringifySgAsmGenericSymbolSymbolDefState(int64_t n, const char *strip=NULL, bool canonic=false);
3645  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolDefState();
3646 }
3647 
3648 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3649 // /src/ROSETTA/src/binaryInstruction.C line 17711
3650 namespace stringify { namespace SgAsmGenericSymbol {
3652  const char* SymbolType(int64_t);
3653 
3655  std::string SymbolType(int64_t, const std::string &strip);
3656 
3658  const std::vector<int64_t>& SymbolType();
3659 }}
3660 
3661 namespace Rose {
3662  std::string stringifySgAsmGenericSymbolSymbolType(int64_t n, const char *strip=NULL, bool canonic=false);
3663  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolType();
3664 }
3665 
3666 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3667 // /src/ROSETTA/src/binaryInstruction.C line 17725
3668 namespace stringify { namespace SgAsmGenericSymbol {
3670  const char* SymbolBinding(int64_t);
3671 
3673  std::string SymbolBinding(int64_t, const std::string &strip);
3674 
3676  const std::vector<int64_t>& SymbolBinding();
3677 }}
3678 
3679 namespace Rose {
3680  std::string stringifySgAsmGenericSymbolSymbolBinding(int64_t n, const char *strip=NULL, bool canonic=false);
3681  const std::vector<int64_t>& stringifySgAsmGenericSymbolSymbolBinding();
3682 }
3683 
3684 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3685 // /src/ROSETTA/src/binaryInstruction.C line 18254
3686 namespace stringify { namespace SgAsmGenericSection {
3688  const char* SectionPurpose(int64_t);
3689 
3691  std::string SectionPurpose(int64_t, const std::string &strip);
3692 
3694  const std::vector<int64_t>& SectionPurpose();
3695 }}
3696 
3697 namespace Rose {
3698  std::string stringifySgAsmGenericSectionSectionPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
3699  const std::vector<int64_t>& stringifySgAsmGenericSectionSectionPurpose();
3700 }
3701 
3702 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3703 // /src/ROSETTA/src/binaryInstruction.C line 19091
3704 namespace stringify { namespace SgAsmGenericFile {
3706  const char* AddressSpace(int64_t);
3707 
3709  std::string AddressSpace(int64_t, const std::string &strip);
3710 
3712  const std::vector<int64_t>& AddressSpace();
3713 }}
3714 
3715 namespace Rose {
3716  std::string stringifySgAsmGenericFileAddressSpace(int64_t n, const char *strip=NULL, bool canonic=false);
3717  const std::vector<int64_t>& stringifySgAsmGenericFileAddressSpace();
3718 }
3719 
3720 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3721 // /src/ROSETTA/src/binaryInstruction.C line 19098
3722 namespace stringify { namespace SgAsmGenericFile {
3724  const char* Elasticity(int64_t);
3725 
3727  std::string Elasticity(int64_t, const std::string &strip);
3728 
3730  const std::vector<int64_t>& Elasticity();
3731 }}
3732 
3733 namespace Rose {
3734  std::string stringifySgAsmGenericFileElasticity(int64_t n, const char *strip=NULL, bool canonic=false);
3735  const std::vector<int64_t>& stringifySgAsmGenericFileElasticity();
3736 }
3737 
3738 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3739 // /src/ROSETTA/src/binaryInstruction.C line 19499
3740 namespace stringify { namespace SgAsmExecutableFileFormat {
3742  const char* ExecFamily(int64_t);
3743 
3745  std::string ExecFamily(int64_t, const std::string &strip);
3746 
3748  const std::vector<int64_t>& ExecFamily();
3749 }}
3750 
3751 namespace Rose {
3752  std::string stringifySgAsmExecutableFileFormatExecFamily(int64_t n, const char *strip=NULL, bool canonic=false);
3753  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecFamily();
3754 }
3755 
3756 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3757 // /src/ROSETTA/src/binaryInstruction.C line 19511
3758 namespace stringify { namespace SgAsmExecutableFileFormat {
3760  const char* ExecABI(int64_t);
3761 
3763  std::string ExecABI(int64_t, const std::string &strip);
3764 
3766  const std::vector<int64_t>& ExecABI();
3767 }}
3768 
3769 namespace Rose {
3770  std::string stringifySgAsmExecutableFileFormatExecABI(int64_t n, const char *strip=NULL, bool canonic=false);
3771  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecABI();
3772 }
3773 
3774 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3775 // /src/ROSETTA/src/binaryInstruction.C line 19536
3776 namespace stringify { namespace SgAsmExecutableFileFormat {
3778  const char* InsSetArchitecture(int64_t);
3779 
3781  std::string InsSetArchitecture(int64_t, const std::string &strip);
3782 
3784  const std::vector<int64_t>& InsSetArchitecture();
3785 }}
3786 
3787 namespace Rose {
3788  std::string stringifySgAsmExecutableFileFormatInsSetArchitecture(int64_t n, const char *strip=NULL, bool canonic=false);
3789  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatInsSetArchitecture();
3790 }
3791 
3792 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3793 // /src/ROSETTA/src/binaryInstruction.C line 19718
3794 namespace stringify { namespace SgAsmExecutableFileFormat {
3796  const char* ExecPurpose(int64_t);
3797 
3799  std::string ExecPurpose(int64_t, const std::string &strip);
3800 
3802  const std::vector<int64_t>& ExecPurpose();
3803 }}
3804 
3805 namespace Rose {
3806  std::string stringifySgAsmExecutableFileFormatExecPurpose(int64_t n, const char *strip=NULL, bool canonic=false);
3807  const std::vector<int64_t>& stringifySgAsmExecutableFileFormatExecPurpose();
3808 }
3809 
3810 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3811 // /src/ROSETTA/src/binaryInstruction.C line 26364
3812 namespace stringify { namespace SgAsmCilMetadataHeap {
3814  const char* ReferenceKind(int64_t);
3815 
3817  std::string ReferenceKind(int64_t, const std::string &strip);
3818 
3820  const std::vector<int64_t>& ReferenceKind();
3821 }}
3822 
3823 namespace Rose {
3824  std::string stringifySgAsmCilMetadataHeapReferenceKind(int64_t n, const char *strip=NULL, bool canonic=false);
3825  const std::vector<int64_t>& stringifySgAsmCilMetadataHeapReferenceKind();
3826 }
3827 
3828 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3829 // /src/ROSETTA/src/grammar.h line 88
3830 namespace stringify {
3832  const char* ConstructParamEnum(int64_t);
3833 
3835  std::string ConstructParamEnum(int64_t, const std::string &strip);
3836 
3838  const std::vector<int64_t>& ConstructParamEnum();
3839 }
3840 
3841 namespace Rose {
3842  std::string stringifyConstructParamEnum(int64_t n, const char *strip=NULL, bool canonic=false);
3843  const std::vector<int64_t>& stringifyConstructParamEnum();
3844 }
3845 
3846 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3847 // /src/ROSETTA/src/grammar.h line 93
3848 namespace stringify {
3850  const char* BuildAccessEnum(int64_t);
3851 
3853  std::string BuildAccessEnum(int64_t, const std::string &strip);
3854 
3856  const std::vector<int64_t>& BuildAccessEnum();
3857 }
3858 
3859 namespace Rose {
3860  std::string stringifyBuildAccessEnum(int64_t n, const char *strip=NULL, bool canonic=false);
3861  const std::vector<int64_t>& stringifyBuildAccessEnum();
3862 }
3863 
3864 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3865 // /src/ROSETTA/src/grammar.h line 101
3866 namespace stringify {
3868  const char* CopyConfigEnum(int64_t);
3869 
3871  std::string CopyConfigEnum(int64_t, const std::string &strip);
3872 
3874  const std::vector<int64_t>& CopyConfigEnum();
3875 }
3876 
3877 namespace Rose {
3878  std::string stringifyCopyConfigEnum(int64_t n, const char *strip=NULL, bool canonic=false);
3879  const std::vector<int64_t>& stringifyCopyConfigEnum();
3880 }
3881 
3882 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3883 // /src/ROSETTA/src/grammar.h line 122
3884 namespace stringify {
3886  const char* TraversalEnum(int64_t);
3887 
3889  std::string TraversalEnum(int64_t, const std::string &strip);
3890 
3892  const std::vector<int64_t>& TraversalEnum();
3893 }
3894 
3895 namespace Rose {
3896  std::string stringifyTraversalEnum(int64_t n, const char *strip=NULL, bool canonic=false);
3897  const std::vector<int64_t>& stringifyTraversalEnum();
3898 }
3899 
3900 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3901 // /src/ROSETTA/src/grammar.h line 127
3902 namespace stringify {
3904  const char* DeleteEnum(int64_t);
3905 
3907  std::string DeleteEnum(int64_t, const std::string &strip);
3908 
3910  const std::vector<int64_t>& DeleteEnum();
3911 }
3912 
3913 namespace Rose {
3914  std::string stringifyDeleteEnum(int64_t n, const char *strip=NULL, bool canonic=false);
3915  const std::vector<int64_t>& stringifyDeleteEnum();
3916 }
3917 
3918 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3919 // /src/util/stringSupport/FileUtility.h line 25
3920 namespace stringify { namespace Rose { namespace StringUtility {
3922  const char* OSType(int64_t);
3923 
3925  std::string OSType(int64_t, const std::string &strip);
3926 
3928  const std::vector<int64_t>& OSType();
3929 }}}
3930 
3931 namespace Rose {
3932  std::string stringifyStringUtilityOSType(int64_t n, const char *strip=NULL, bool canonic=false);
3933  const std::vector<int64_t>& stringifyStringUtilityOSType();
3934 }
3935 
3936 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3937 // /src/util/stringSupport/FileUtility.h line 150
3938 namespace stringify { namespace Rose { namespace StringUtility {
3940  const char* FileNameLocation(int64_t);
3941 
3943  std::string FileNameLocation(int64_t, const std::string &strip);
3944 
3946  const std::vector<int64_t>& FileNameLocation();
3947 }}}
3948 
3949 namespace Rose {
3950  std::string stringifyStringUtilityFileNameLocation(int64_t n, const char *strip=NULL, bool canonic=false);
3951  const std::vector<int64_t>& stringifyStringUtilityFileNameLocation();
3952 }
3953 
3954 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3955 // /src/util/Sawyer/DocumentMarkup.h line 42
3956 namespace stringify { namespace Sawyer { namespace Document { namespace Markup {
3958  const char* TokenType(int64_t);
3959 
3961  std::string TokenType(int64_t, const std::string &strip);
3962 
3964  const std::vector<int64_t>& TokenType();
3965 }}}}
3966 
3967 namespace Rose {
3968  std::string stringifySawyerDocumentMarkupTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
3969  const std::vector<int64_t>& stringifySawyerDocumentMarkupTokenType();
3970 }
3971 
3972 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3973 // /src/util/Sawyer/CommandLine.h line 173
3974 namespace stringify { namespace Sawyer { namespace CommandLine {
3976  const char* SortOrder(int64_t);
3977 
3979  std::string SortOrder(int64_t, const std::string &strip);
3980 
3982  const std::vector<int64_t>& SortOrder();
3983 }}}
3984 
3985 namespace Rose {
3986  std::string stringifySawyerCommandLineSortOrder(int64_t n, const char *strip=NULL, bool canonic=false);
3987  const std::vector<int64_t>& stringifySawyerCommandLineSortOrder();
3988 }
3989 
3990 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
3991 // /src/util/Sawyer/CommandLine.h line 186
3992 namespace stringify { namespace Sawyer { namespace CommandLine {
3994  const char* Canonical(int64_t);
3995 
3997  std::string Canonical(int64_t, const std::string &strip);
3998 
4000  const std::vector<int64_t>& Canonical();
4001 }}}
4002 
4003 namespace Rose {
4004  std::string stringifySawyerCommandLineCanonical(int64_t n, const char *strip=NULL, bool canonic=false);
4005  const std::vector<int64_t>& stringifySawyerCommandLineCanonical();
4006 }
4007 
4008 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4009 // /src/util/Sawyer/CommandLine.h line 194
4010 namespace stringify { namespace Sawyer { namespace CommandLine {
4012  const char* ShowGroupName(int64_t);
4013 
4015  std::string ShowGroupName(int64_t, const std::string &strip);
4016 
4018  const std::vector<int64_t>& ShowGroupName();
4019 }}}
4020 
4021 namespace Rose {
4022  std::string stringifySawyerCommandLineShowGroupName(int64_t n, const char *strip=NULL, bool canonic=false);
4023  const std::vector<int64_t>& stringifySawyerCommandLineShowGroupName();
4024 }
4025 
4026 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4027 // /src/util/Sawyer/CommandLine.h line 202
4028 namespace stringify { namespace Sawyer { namespace CommandLine {
4030  const char* SwitchSkipping(int64_t);
4031 
4033  std::string SwitchSkipping(int64_t, const std::string &strip);
4034 
4036  const std::vector<int64_t>& SwitchSkipping();
4037 }}}
4038 
4039 namespace Rose {
4040  std::string stringifySawyerCommandLineSwitchSkipping(int64_t n, const char *strip=NULL, bool canonic=false);
4041  const std::vector<int64_t>& stringifySawyerCommandLineSwitchSkipping();
4042 }
4043 
4044 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4045 // /src/util/Sawyer/CommandLine.h line 2010
4046 namespace stringify { namespace Sawyer { namespace CommandLine {
4048  const char* WhichValue(int64_t);
4049 
4051  std::string WhichValue(int64_t, const std::string &strip);
4052 
4054  const std::vector<int64_t>& WhichValue();
4055 }}}
4056 
4057 namespace Rose {
4058  std::string stringifySawyerCommandLineWhichValue(int64_t n, const char *strip=NULL, bool canonic=false);
4059  const std::vector<int64_t>& stringifySawyerCommandLineWhichValue();
4060 }
4061 
4062 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4063 // /src/util/Sawyer/CommandLine.h line 3065
4064 namespace stringify { namespace Sawyer { namespace CommandLine { namespace Parser {
4066  const char* GroupingFlags(int64_t);
4067 
4069  std::string GroupingFlags(int64_t, const std::string &strip);
4070 
4072  const std::vector<int64_t>& GroupingFlags();
4073 }}}}
4074 
4075 namespace Rose {
4076  std::string stringifySawyerCommandLineParserGroupingFlags(int64_t n, const char *strip=NULL, bool canonic=false);
4077  const std::vector<int64_t>& stringifySawyerCommandLineParserGroupingFlags();
4078 }
4079 
4080 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4081 // /src/util/Sawyer/Graph.h line 636
4082 namespace stringify { namespace Sawyer { namespace Container { namespace Graph {
4084  const char* EdgePhase(int64_t);
4085 
4087  std::string EdgePhase(int64_t, const std::string &strip);
4088 
4090  const std::vector<int64_t>& EdgePhase();
4091 }}}}
4092 
4093 namespace Rose {
4094  std::string stringifySawyerContainerGraphEdgePhase(int64_t n, const char *strip=NULL, bool canonic=false);
4095  const std::vector<int64_t>& stringifySawyerContainerGraphEdgePhase();
4096 }
4097 
4098 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4099 // /src/util/Sawyer/Tree.h line 119
4100 namespace stringify { namespace Sawyer { namespace Tree {
4102  const char* TraversalEvent(int64_t);
4103 
4105  std::string TraversalEvent(int64_t, const std::string &strip);
4106 
4108  const std::vector<int64_t>& TraversalEvent();
4109 }}}
4110 
4111 namespace Rose {
4112  std::string stringifySawyerTreeTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
4113  const std::vector<int64_t>& stringifySawyerTreeTraversalEvent();
4114 }
4115 
4116 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4117 // /src/util/Sawyer/Tree.h line 125
4118 namespace stringify { namespace Sawyer { namespace Tree {
4120  const char* TraversalAction(int64_t);
4121 
4123  std::string TraversalAction(int64_t, const std::string &strip);
4124 
4126  const std::vector<int64_t>& TraversalAction();
4127 }}}
4128 
4129 namespace Rose {
4130  std::string stringifySawyerTreeTraversalAction(int64_t n, const char *strip=NULL, bool canonic=false);
4131  const std::vector<int64_t>& stringifySawyerTreeTraversalAction();
4132 }
4133 
4134 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4135 // /src/util/Sawyer/Tree.h line 481
4136 namespace stringify { namespace Sawyer { namespace Tree { namespace Node {
4138  const char* TraversalDirection(int64_t);
4139 
4141  std::string TraversalDirection(int64_t, const std::string &strip);
4142 
4144  const std::vector<int64_t>& TraversalDirection();
4145 }}}}
4146 
4147 namespace Rose {
4148  std::string stringifySawyerTreeNodeTraversalDirection(int64_t n, const char *strip=NULL, bool canonic=false);
4149  const std::vector<int64_t>& stringifySawyerTreeNodeTraversalDirection();
4150 }
4151 
4152 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4153 // /src/util/Sawyer/stringifyEnums.C line 39
4154 namespace stringify {
4156  const char* Generate(int64_t);
4157 
4159  std::string Generate(int64_t, const std::string &strip);
4160 
4162  const std::vector<int64_t>& Generate();
4163 }
4164 
4165 namespace Rose {
4166  std::string stringifyGenerate(int64_t n, const char *strip=NULL, bool canonic=false);
4167  const std::vector<int64_t>& stringifyGenerate();
4168 }
4169 
4170 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4171 // /src/util/Sawyer/stringifyEnums.C line 46
4172 namespace stringify {
4174  const char* Flag(int64_t);
4175 
4177  std::string Flag(int64_t, const std::string &strip);
4178 
4180  const std::vector<int64_t>& Flag();
4181 }
4182 
4183 namespace Rose {
4184  std::string stringifyFlag(int64_t n, const char *strip=NULL, bool canonic=false);
4185  const std::vector<int64_t>& stringifyFlag();
4186 }
4187 
4188 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4189 // /src/util/Sawyer/Access.h line 19
4190 namespace stringify { namespace Sawyer { namespace Access {
4192  const char* Access(int64_t);
4193 
4195  std::string Access(int64_t, const std::string &strip);
4196 
4198  const std::vector<int64_t>& Access();
4199 }}}
4200 
4201 namespace Rose {
4202  std::string stringifySawyerAccessAccess(int64_t n, const char *strip=NULL, bool canonic=false);
4203  const std::vector<int64_t>& stringifySawyerAccessAccess();
4204 }
4205 
4206 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4207 // /src/util/Sawyer/Clexer.h line 25
4208 namespace stringify { namespace Sawyer { namespace Language { namespace Clexer {
4210  const char* TokenType(int64_t);
4211 
4213  std::string TokenType(int64_t, const std::string &strip);
4214 
4216  const std::vector<int64_t>& TokenType();
4217 }}}}
4218 
4219 namespace Rose {
4220  std::string stringifySawyerLanguageClexerTokenType(int64_t n, const char *strip=NULL, bool canonic=false);
4221  const std::vector<int64_t>& stringifySawyerLanguageClexerTokenType();
4222 }
4223 
4224 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4225 // /src/util/Sawyer/GraphTraversal.h line 39
4226 namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
4228  const char* TraversalEvent(int64_t);
4229 
4231  std::string TraversalEvent(int64_t, const std::string &strip);
4232 
4234  const std::vector<int64_t>& TraversalEvent();
4235 }}}}
4236 
4237 namespace Rose {
4238  std::string stringifySawyerContainerAlgorithmTraversalEvent(int64_t n, const char *strip=NULL, bool canonic=false);
4239  const std::vector<int64_t>& stringifySawyerContainerAlgorithmTraversalEvent();
4240 }
4241 
4242 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4243 // /src/util/Sawyer/GraphAlgorithm.h line 374
4244 namespace stringify { namespace Sawyer { namespace Container { namespace Algorithm {
4246  const char* CsiNextAction(int64_t);
4247 
4249  std::string CsiNextAction(int64_t, const std::string &strip);
4250 
4252  const std::vector<int64_t>& CsiNextAction();
4253 }}}}
4254 
4255 namespace Rose {
4256  std::string stringifySawyerContainerAlgorithmCsiNextAction(int64_t n, const char *strip=NULL, bool canonic=false);
4257  const std::vector<int64_t>& stringifySawyerContainerAlgorithmCsiNextAction();
4258 }
4259 
4260 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4261 // /src/util/Sawyer/Database.h line 293
4262 namespace stringify { namespace Sawyer { namespace Database { namespace Statement {
4264  const char* State(int64_t);
4265 
4267  std::string State(int64_t, const std::string &strip);
4268 
4270  const std::vector<int64_t>& State();
4271 }}}}
4272 
4273 namespace Rose {
4274  std::string stringifySawyerDatabaseStatementState(int64_t n, const char *strip=NULL, bool canonic=false);
4275  const std::vector<int64_t>& stringifySawyerDatabaseStatementState();
4276 }
4277 
4278 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4279 // /src/util/Sawyer/Message.h line 313
4280 namespace stringify { namespace Sawyer { namespace Message {
4282  const char* Importance(int64_t);
4283 
4285  std::string Importance(int64_t, const std::string &strip);
4286 
4288  const std::vector<int64_t>& Importance();
4289 }}}
4290 
4291 namespace Rose {
4292  std::string stringifySawyerMessageImportance(int64_t n, const char *strip=NULL, bool canonic=false);
4293  const std::vector<int64_t>& stringifySawyerMessageImportance();
4294 }
4295 
4296 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4297 // /src/util/Sawyer/Message.h line 343
4298 namespace stringify { namespace Sawyer { namespace Message {
4300  const char* AnsiColor(int64_t);
4301 
4303  std::string AnsiColor(int64_t, const std::string &strip);
4304 
4306  const std::vector<int64_t>& AnsiColor();
4307 }}}
4308 
4309 namespace Rose {
4310  std::string stringifySawyerMessageAnsiColor(int64_t n, const char *strip=NULL, bool canonic=false);
4311  const std::vector<int64_t>& stringifySawyerMessageAnsiColor();
4312 }
4313 
4314 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4315 // /src/util/Sawyer/Message.h line 990
4316 namespace stringify { namespace Sawyer { namespace Message { namespace Prefix {
4318  const char* When(int64_t);
4319 
4321  std::string When(int64_t, const std::string &strip);
4322 
4324  const std::vector<int64_t>& When();
4325 }}}}
4326 
4327 namespace Rose {
4328  std::string stringifySawyerMessagePrefixWhen(int64_t n, const char *strip=NULL, bool canonic=false);
4329  const std::vector<int64_t>& stringifySawyerMessagePrefixWhen();
4330 }
4331 
4332 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4333 // /src/midend/astProcessing/AstAttributeMechanism.C line 21
4334 namespace stringify {
4336  const char* WarningType(int64_t);
4337 
4339  std::string WarningType(int64_t, const std::string &strip);
4340 
4342  const std::vector<int64_t>& WarningType();
4343 }
4344 
4345 namespace Rose {
4346  std::string stringifyWarningType(int64_t n, const char *strip=NULL, bool canonic=false);
4347  const std::vector<int64_t>& stringifyWarningType();
4348 }
4349 
4350 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4351 // /src/midend/astProcessing/AstAttributeMechanism.h line 41
4352 namespace stringify { namespace AstAttribute {
4354  const char* OwnershipPolicy(int64_t);
4355 
4357  std::string OwnershipPolicy(int64_t, const std::string &strip);
4358 
4360  const std::vector<int64_t>& OwnershipPolicy();
4361 }}
4362 
4363 namespace Rose {
4364  std::string stringifyAstAttributeOwnershipPolicy(int64_t n, const char *strip=NULL, bool canonic=false);
4365  const std::vector<int64_t>& stringifyAstAttributeOwnershipPolicy();
4366 }
4367 
4368 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4369 // /src/midend/astProcessing/AstRestructure.h line 22
4370 namespace stringify { namespace AstUnparseAttribute {
4372  const char* RelativePositionType(int64_t);
4373 
4375  std::string RelativePositionType(int64_t, const std::string &strip);
4376 
4378  const std::vector<int64_t>& RelativePositionType();
4379 }}
4380 
4381 namespace Rose {
4382  std::string stringifyAstUnparseAttributeRelativePositionType(int64_t n, const char *strip=NULL, bool canonic=false);
4383  const std::vector<int64_t>& stringifyAstUnparseAttributeRelativePositionType();
4384 }
4385 
4386 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4387 // /src/midend/astMatching/matcherparser.C line 1846
4388 namespace stringify {
4390  const char* yytokentype(int64_t);
4391 
4393  std::string yytokentype(int64_t, const std::string &strip);
4394 
4396  const std::vector<int64_t>& yytokentype();
4397 }
4398 
4399 namespace Rose {
4400  std::string stringify_yytokentype(int64_t n, const char *strip=NULL, bool canonic=false);
4401  const std::vector<int64_t>& stringify_yytokentype();
4402 }
4403 
4404 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4405 // /src/midend/astMatching/MatchOperation.h line 40
4406 namespace stringify { namespace MatchStatus {
4408  const char* PatternMatchMode(int64_t);
4409 
4411  std::string PatternMatchMode(int64_t, const std::string &strip);
4412 
4414  const std::vector<int64_t>& PatternMatchMode();
4415 }}
4416 
4417 namespace Rose {
4418  std::string stringifyMatchStatusPatternMatchMode(int64_t n, const char *strip=NULL, bool canonic=false);
4419  const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode();
4420 }
4421 
4422 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4423 // /src/midend/astMatching/MatchOperation.h line 41
4424 namespace stringify { namespace MatchStatus {
4426  const char* CheckNodeMode(int64_t);
4427 
4429  std::string CheckNodeMode(int64_t, const std::string &strip);
4430 
4432  const std::vector<int64_t>& CheckNodeMode();
4433 }}
4434 
4435 namespace Rose {
4436  std::string stringifyMatchStatusCheckNodeMode(int64_t n, const char *strip=NULL, bool canonic=false);
4437  const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode();
4438 }
4439 
4440 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4441 // /src/midend/BinaryAnalysis/libraryIdentification/libraryIdentification.h line 18
4442 namespace stringify { namespace LibraryIdentification {
4444  const char* DUPLICATE_OPTION(int64_t);
4445 
4447  std::string DUPLICATE_OPTION(int64_t, const std::string &strip);
4448 
4450  const std::vector<int64_t>& DUPLICATE_OPTION();
4451 }}
4452 
4453 namespace Rose {
4454  std::string stringifyLibraryIdentificationDUPLICATE_OPTION(int64_t n, const char *strip=NULL, bool canonic=false);
4455  const std::vector<int64_t>& stringifyLibraryIdentificationDUPLICATE_OPTION();
4456 }
4457 
4458 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4459 // /src/midend/astSnippet/Snippet.h line 319
4460 namespace stringify { namespace Rose { namespace Snippet {
4462  const char* InsertMechanism(int64_t);
4463 
4465  std::string InsertMechanism(int64_t, const std::string &strip);
4466 
4468  const std::vector<int64_t>& InsertMechanism();
4469 }}}
4470 
4471 namespace Rose {
4472  std::string stringifySnippetInsertMechanism(int64_t n, const char *strip=NULL, bool canonic=false);
4473  const std::vector<int64_t>& stringifySnippetInsertMechanism();
4474 }
4475 
4476 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4477 // /src/midend/astSnippet/Snippet.h line 329
4478 namespace stringify { namespace Rose { namespace Snippet {
4480  const char* LocalDeclarationPosition(int64_t);
4481 
4483  std::string LocalDeclarationPosition(int64_t, const std::string &strip);
4484 
4486  const std::vector<int64_t>& LocalDeclarationPosition();
4487 }}}
4488 
4489 namespace Rose {
4490  std::string stringifySnippetLocalDeclarationPosition(int64_t n, const char *strip=NULL, bool canonic=false);
4491  const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition();
4492 }
4493 
4494 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4495 // /src/midend/astRewriteMechanism/rewrite.h line 52
4496 namespace stringify { namespace MidLevelCollectionTypedefs {
4498  const char* ScopeIdentifier_Enum(int64_t);
4499 
4501  std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);
4502 
4504  const std::vector<int64_t>& ScopeIdentifier_Enum();
4505 }}
4506 
4507 namespace Rose {
4508  std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4509  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum();
4510 }
4511 
4512 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4513 // /src/midend/astRewriteMechanism/rewrite.h line 66
4514 namespace stringify { namespace MidLevelCollectionTypedefs {
4516  const char* PlacementPosition_Enum(int64_t);
4517 
4519  std::string PlacementPosition_Enum(int64_t, const std::string &strip);
4520 
4522  const std::vector<int64_t>& PlacementPosition_Enum();
4523 }}
4524 
4525 namespace Rose {
4526  std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4527  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum();
4528 }
4529 
4530 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4531 // /src/midend/astRewriteMechanism/rewrite.h line 79
4532 namespace stringify { namespace MidLevelCollectionTypedefs {
4534  const char* IntermediateFileStringPosition_Enum(int64_t);
4535 
4537  std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);
4538 
4540  const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
4541 }}
4542 
4543 namespace Rose {
4544  std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4545  const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
4546 }
4547 
4548 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4549 // /src/midend/astRewriteMechanism/rewrite.h line 141
4550 namespace stringify { namespace HighLevelCollectionTypedefs {
4552  const char* ScopeIdentifier_Enum(int64_t);
4553 
4555  std::string ScopeIdentifier_Enum(int64_t, const std::string &strip);
4556 
4558  const std::vector<int64_t>& ScopeIdentifier_Enum();
4559 }}
4560 
4561 namespace Rose {
4562  std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4563  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum();
4564 }
4565 
4566 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4567 // /src/midend/astRewriteMechanism/rewrite.h line 162
4568 namespace stringify { namespace HighLevelCollectionTypedefs {
4570  const char* PlacementPosition_Enum(int64_t);
4571 
4573  std::string PlacementPosition_Enum(int64_t, const std::string &strip);
4574 
4576  const std::vector<int64_t>& PlacementPosition_Enum();
4577 }}
4578 
4579 namespace Rose {
4580  std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4581  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum();
4582 }
4583 
4584 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4585 // /src/midend/astRewriteMechanism/rewrite.h line 176
4586 namespace stringify { namespace HighLevelCollectionTypedefs {
4588  const char* IntermediateFileStringPosition_Enum(int64_t);
4589 
4591  std::string IntermediateFileStringPosition_Enum(int64_t, const std::string &strip);
4592 
4594  const std::vector<int64_t>& IntermediateFileStringPosition_Enum();
4595 }}
4596 
4597 namespace Rose {
4598  std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t n, const char *strip=NULL, bool canonic=false);
4599  const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum();
4600 }
4601 
4602 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4603 // /src/midend/abstractLayer/Labeler.h line 15
4604 namespace stringify { namespace CodeThorn { namespace LabelProperty {
4606  const char* LabelType(int64_t);
4607 
4609  std::string LabelType(int64_t, const std::string &strip);
4610 
4612  const std::vector<int64_t>& LabelType();
4613 }}}
4614 
4615 namespace Rose {
4616  std::string stringifyCodeThornLabelPropertyLabelType(int64_t n, const char *strip=NULL, bool canonic=false);
4617  const std::vector<int64_t>& stringifyCodeThornLabelPropertyLabelType();
4618 }
4619 
4620 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4621 // /src/midend/abstractLayer/Labeler.h line 50
4622 namespace stringify { namespace CodeThorn { namespace LabelProperty {
4624  const char* IOType(int64_t);
4625 
4627  std::string IOType(int64_t, const std::string &strip);
4628 
4630  const std::vector<int64_t>& IOType();
4631 }}}
4632 
4633 namespace Rose {
4634  std::string stringifyCodeThornLabelPropertyIOType(int64_t n, const char *strip=NULL, bool canonic=false);
4635  const std::vector<int64_t>& stringifyCodeThornLabelPropertyIOType();
4636 }
4637 
4638 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4639 // /src/midend/abstractLayer/VariableIdMapping.h line 174
4640 namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
4642  const char* AggregateType(int64_t);
4643 
4645  std::string AggregateType(int64_t, const std::string &strip);
4646 
4648  const std::vector<int64_t>& AggregateType();
4649 }}}
4650 
4651 namespace Rose {
4652  std::string stringifyCodeThornVariableIdMappingAggregateType(int64_t n, const char *strip=NULL, bool canonic=false);
4653  const std::vector<int64_t>& stringifyCodeThornVariableIdMappingAggregateType();
4654 }
4655 
4656 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4657 // /src/midend/abstractLayer/VariableIdMapping.h line 175
4658 namespace stringify { namespace CodeThorn { namespace VariableIdMapping {
4660  const char* VariableScope(int64_t);
4661 
4663  std::string VariableScope(int64_t, const std::string &strip);
4664 
4666  const std::vector<int64_t>& VariableScope();
4667 }}}
4668 
4669 namespace Rose {
4670  std::string stringifyCodeThornVariableIdMappingVariableScope(int64_t n, const char *strip=NULL, bool canonic=false);
4671  const std::vector<int64_t>& stringifyCodeThornVariableIdMappingVariableScope();
4672 }
4673 
4674 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4675 // /src/midend/abstractLayer/SgNodeHelper.h line 542
4676 namespace stringify { namespace SgNodeHelper { namespace Pattern { namespace OutputTarget {
4678  const char* OType(int64_t);
4679 
4681  std::string OType(int64_t, const std::string &strip);
4682 
4684  const std::vector<int64_t>& OType();
4685 }}}}
4686 
4687 namespace Rose {
4688  std::string stringifySgNodeHelperPatternOutputTargetOType(int64_t n, const char *strip=NULL, bool canonic=false);
4689  const std::vector<int64_t>& stringifySgNodeHelperPatternOutputTargetOType();
4690 }
4691 
4692 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4693 // /src/midend/programTransformation/ompLowering/xomp.c line 63
4694 namespace stringify {
4696  const char* omp_rtl_enum(int64_t);
4697 
4699  std::string omp_rtl_enum(int64_t, const std::string &strip);
4700 
4702  const std::vector<int64_t>& omp_rtl_enum();
4703 }
4704 
4705 namespace Rose {
4706  std::string stringify_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
4707  const std::vector<int64_t>& stringify_omp_rtl_enum();
4708 }
4709 
4710 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4711 // /src/midend/programTransformation/ompLowering/omp_lowering.h line 37
4712 namespace stringify { namespace OmpSupport {
4714  const char* omp_rtl_enum(int64_t);
4715 
4717  std::string omp_rtl_enum(int64_t, const std::string &strip);
4718 
4720  const std::vector<int64_t>& omp_rtl_enum();
4721 }}
4722 
4723 namespace Rose {
4724  std::string stringifyOmpSupport_omp_rtl_enum(int64_t n, const char *strip=NULL, bool canonic=false);
4725  const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum();
4726 }
4727 
4728 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4729 // /src/midend/programTransformation/implicitCodeGeneration/defaultFunctionGenerator.C line 17
4730 namespace stringify {
4732  const char* defaultEnumFunctionType(int64_t);
4733 
4735  std::string defaultEnumFunctionType(int64_t, const std::string &strip);
4736 
4738  const std::vector<int64_t>& defaultEnumFunctionType();
4739 }
4740 
4741 namespace Rose {
4742  std::string stringify_defaultEnumFunctionType(int64_t n, const char *strip=NULL, bool canonic=false);
4743  const std::vector<int64_t>& stringify_defaultEnumFunctionType();
4744 }
4745 
4746 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4747 // /src/midend/programTransformation/extractFunctionArgumentsNormalization/functionEvaluationOrderTraversal.h line 40
4748 namespace stringify { namespace FunctionCallInfo {
4750  const char* InsertionMode(int64_t);
4751 
4753  std::string InsertionMode(int64_t, const std::string &strip);
4754 
4756  const std::vector<int64_t>& InsertionMode();
4757 }}
4758 
4759 namespace Rose {
4760  std::string stringifyFunctionCallInfoInsertionMode(int64_t n, const char *strip=NULL, bool canonic=false);
4761  const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode();
4762 }
4763 
4764 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4765 // /src/midend/astQuery/booleanQuery.h line 43
4766 namespace stringify { namespace BooleanQuery {
4768  const char* TypeOfQueryType(int64_t);
4769 
4771  std::string TypeOfQueryType(int64_t, const std::string &strip);
4772 
4774  const std::vector<int64_t>& TypeOfQueryType();
4775 }}
4776 
4777 namespace Rose {
4778  std::string stringifyBooleanQueryTypeOfQueryType(int64_t n, const char *strip=NULL, bool canonic=false);
4779  const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType();
4780 }
4781 
4782 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4783 // /src/midend/astQuery/nameQuery.h line 74
4784 namespace stringify { namespace NameQuery {
4786  const char* TypeOfQueryTypeOneParameter(int64_t);
4787 
4789  std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
4790 
4792  const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
4793 }}
4794 
4795 namespace Rose {
4796  std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
4797  const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter();
4798 }
4799 
4800 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4801 // /src/midend/astQuery/nameQuery.h line 94
4802 namespace stringify { namespace NameQuery {
4804  const char* TypeOfQueryTypeTwoParameters(int64_t);
4805 
4807  std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
4808 
4810  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
4811 }}
4812 
4813 namespace Rose {
4814  std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
4815  const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters();
4816 }
4817 
4818 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4819 // /src/midend/astQuery/astQuery.h line 97
4820 namespace stringify { namespace AstQueryNamespace {
4822  const char* QueryDepth(int64_t);
4823 
4825  std::string QueryDepth(int64_t, const std::string &strip);
4826 
4828  const std::vector<int64_t>& QueryDepth();
4829 }}
4830 
4831 namespace Rose {
4832  std::string stringifyAstQueryNamespaceQueryDepth(int64_t n, const char *strip=NULL, bool canonic=false);
4833  const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth();
4834 }
4835 
4836 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4837 // /src/midend/astQuery/nodeQuery.h line 133
4838 namespace stringify { namespace NodeQuery {
4840  const char* TypeOfQueryTypeOneParameter(int64_t);
4841 
4843  std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
4844 
4846  const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
4847 }}
4848 
4849 namespace Rose {
4850  std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
4851  const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter();
4852 }
4853 
4854 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4855 // /src/midend/astQuery/nodeQuery.h line 154
4856 namespace stringify { namespace NodeQuery {
4858  const char* TypeOfQueryTypeTwoParameters(int64_t);
4859 
4861  std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
4862 
4864  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
4865 }}
4866 
4867 namespace Rose {
4868  std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
4869  const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters();
4870 }
4871 
4872 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4873 // /src/midend/astQuery/numberQuery.h line 10
4874 namespace stringify { namespace NumberQuery {
4876  const char* TypeOfQueryTypeOneParameter(int64_t);
4877 
4879  std::string TypeOfQueryTypeOneParameter(int64_t, const std::string &strip);
4880 
4882  const std::vector<int64_t>& TypeOfQueryTypeOneParameter();
4883 }}
4884 
4885 namespace Rose {
4886  std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t n, const char *strip=NULL, bool canonic=false);
4887  const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter();
4888 }
4889 
4890 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4891 // /src/midend/astQuery/numberQuery.h line 19
4892 namespace stringify { namespace NumberQuery {
4894  const char* TypeOfQueryTypeTwoParameters(int64_t);
4895 
4897  std::string TypeOfQueryTypeTwoParameters(int64_t, const std::string &strip);
4898 
4900  const std::vector<int64_t>& TypeOfQueryTypeTwoParameters();
4901 }}
4902 
4903 namespace Rose {
4904  std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t n, const char *strip=NULL, bool canonic=false);
4905  const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters();
4906 }
4907 
4908 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4909 // /src/midend/abstractMemoryObject/memory_object_impl.h line 84
4910 namespace stringify { namespace AbstractMemoryObject { namespace IndexSet {
4912  const char* Index_type(int64_t);
4913 
4915  std::string Index_type(int64_t, const std::string &strip);
4916 
4918  const std::vector<int64_t>& Index_type();
4919 }}}
4920 
4921 namespace Rose {
4922  std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t n, const char *strip=NULL, bool canonic=false);
4923  const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type();
4924 }
4925 
4926 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4927 // /src/midend/programAnalysis/staticSingleAssignment/reachingDef.h line 18
4928 namespace stringify { namespace ReachingDef {
4930  const char* Type(int64_t);
4931 
4933  std::string Type(int64_t, const std::string &strip);
4934 
4936  const std::vector<int64_t>& Type();
4937 }}
4938 
4939 namespace Rose {
4940  std::string stringifyReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
4941  const std::vector<int64_t>& stringifyReachingDefType();
4942 }
4943 
4944 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4945 // /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 163
4946 namespace stringify {
4948  const char* IRProcType(int64_t);
4949 
4951  std::string IRProcType(int64_t, const std::string &strip);
4952 
4954  const std::vector<int64_t>& IRProcType();
4955 }
4956 
4957 namespace Rose {
4958  std::string stringifyIRProcType(int64_t n, const char *strip=NULL, bool canonic=false);
4959  const std::vector<int64_t>& stringifyIRProcType();
4960 }
4961 
4962 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4963 // /src/midend/programAnalysis/OpenAnalysis/Interface/IRInterface.h line 173
4964 namespace stringify {
4966  const char* IRStmtType(int64_t);
4967 
4969  std::string IRStmtType(int64_t, const std::string &strip);
4970 
4972  const std::vector<int64_t>& IRStmtType();
4973 }
4974 
4975 namespace Rose {
4976  std::string stringifyIRStmtType(int64_t n, const char *strip=NULL, bool canonic=false);
4977  const std::vector<int64_t>& stringifyIRStmtType();
4978 }
4979 
4980 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4981 // /src/midend/programAnalysis/OpenAnalysis/CallGraph/CallGraph.h line 73
4982 namespace stringify { namespace CallGraph {
4984  const char* EdgeType(int64_t);
4985 
4987  std::string EdgeType(int64_t, const std::string &strip);
4988 
4990  const std::vector<int64_t>& EdgeType();
4991 }}
4992 
4993 namespace Rose {
4994  std::string stringifyCallGraphEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
4995  const std::vector<int64_t>& stringifyCallGraphEdgeType();
4996 }
4997 
4998 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
4999 // /src/midend/programAnalysis/OpenAnalysis/Utils/BaseGraph.h line 261
5000 namespace stringify { namespace BaseGraph { namespace BiDirNodesIterator {
5002  const char* dirType(int64_t);
5003 
5005  std::string dirType(int64_t, const std::string &strip);
5006 
5008  const std::vector<int64_t>& dirType();
5009 }}}
5010 
5011 namespace Rose {
5012  std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t n, const char *strip=NULL, bool canonic=false);
5013  const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType();
5014 }
5015 
5016 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5017 // /src/midend/programAnalysis/OpenAnalysis/CFG/CFG.h line 83
5018 namespace stringify { namespace CFG {
5020  const char* EdgeType(int64_t);
5021 
5023  std::string EdgeType(int64_t, const std::string &strip);
5024 
5026  const std::vector<int64_t>& EdgeType();
5027 }}
5028 
5029 namespace Rose {
5030  std::string stringifyCFG_EdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
5031  const std::vector<int64_t>& stringifyCFG_EdgeType();
5032 }
5033 
5034 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5035 // /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 63
5036 namespace stringify { namespace RIFG {
5038  const char* EdgeDirection(int64_t);
5039 
5041  std::string EdgeDirection(int64_t, const std::string &strip);
5042 
5044  const std::vector<int64_t>& EdgeDirection();
5045 }}
5046 
5047 namespace Rose {
5048  std::string stringifyRIFG_EdgeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
5049  const std::vector<int64_t>& stringifyRIFG_EdgeDirection();
5050 }
5051 
5052 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5053 // /src/midend/programAnalysis/OpenAnalysis/CFG/RIFG.h line 64
5054 namespace stringify { namespace RIFG {
5056  const char* ForwardBackward(int64_t);
5057 
5059  std::string ForwardBackward(int64_t, const std::string &strip);
5060 
5062  const std::vector<int64_t>& ForwardBackward();
5063 }}
5064 
5065 namespace Rose {
5066  std::string stringifyRIFG_ForwardBackward(int64_t n, const char *strip=NULL, bool canonic=false);
5067  const std::vector<int64_t>& stringifyRIFG_ForwardBackward();
5068 }
5069 
5070 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5071 // /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 65
5072 namespace stringify {
5074  const char* RITarjType(int64_t);
5075 
5077  std::string RITarjType(int64_t, const std::string &strip);
5078 
5080  const std::vector<int64_t>& RITarjType();
5081 }
5082 
5083 namespace Rose {
5084  std::string stringifyRITarjType(int64_t n, const char *strip=NULL, bool canonic=false);
5085  const std::vector<int64_t>& stringifyRITarjType();
5086 }
5087 
5088 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5089 // /src/midend/programAnalysis/OpenAnalysis/CFG/TarjanIntervals.h line 67
5090 namespace stringify {
5092  const char* RITarjEdgeType(int64_t);
5093 
5095  std::string RITarjEdgeType(int64_t, const std::string &strip);
5096 
5098  const std::vector<int64_t>& RITarjEdgeType();
5099 }
5100 
5101 namespace Rose {
5102  std::string stringifyRITarjEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
5103  const std::vector<int64_t>& stringifyRITarjEdgeType();
5104 }
5105 
5106 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5107 // /src/midend/programAnalysis/EditDistance/TreeEditDistance.h line 60
5108 namespace stringify { namespace Rose { namespace EditDistance { namespace TreeEditDistance {
5110  const char* EditType(int64_t);
5111 
5113  std::string EditType(int64_t, const std::string &strip);
5114 
5116  const std::vector<int64_t>& EditType();
5117 }}}}
5118 
5119 namespace Rose {
5120  std::string stringifyEditDistanceTreeEditDistanceEditType(int64_t n, const char *strip=NULL, bool canonic=false);
5121  const std::vector<int64_t>& stringifyEditDistanceTreeEditDistanceEditType();
5122 }
5123 
5124 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5125 // /src/midend/programAnalysis/systemDependenceGraph/PDG.h line 32
5126 namespace stringify { namespace SDG { namespace PDGEdge {
5128  const char* EdgeType(int64_t);
5129 
5131  std::string EdgeType(int64_t, const std::string &strip);
5132 
5134  const std::vector<int64_t>& EdgeType();
5135 }}}
5136 
5137 namespace Rose {
5138  std::string stringifySDG_PDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
5139  const std::vector<int64_t>& stringifySDG_PDGEdgeEdgeType();
5140 }
5141 
5142 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5143 // /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 21
5144 namespace stringify { namespace SDG { namespace SDGNode {
5146  const char* NodeType(int64_t);
5147 
5149  std::string NodeType(int64_t, const std::string &strip);
5150 
5152  const std::vector<int64_t>& NodeType();
5153 }}}
5154 
5155 namespace Rose {
5156  std::string stringifySDG_SDGNodeNodeType(int64_t n, const char *strip=NULL, bool canonic=false);
5157  const std::vector<int64_t>& stringifySDG_SDGNodeNodeType();
5158 }
5159 
5160 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5161 // /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 48
5162 namespace stringify { namespace SDG { namespace SDGEdge {
5164  const char* EdgeType(int64_t);
5165 
5167  std::string EdgeType(int64_t, const std::string &strip);
5168 
5170  const std::vector<int64_t>& EdgeType();
5171 }}}
5172 
5173 namespace Rose {
5174  std::string stringifySDG_SDGEdgeEdgeType(int64_t n, const char *strip=NULL, bool canonic=false);
5175  const std::vector<int64_t>& stringifySDG_SDGEdgeEdgeType();
5176 }
5177 
5178 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5179 // /src/midend/programAnalysis/systemDependenceGraph/SDG.h line 58
5180 namespace stringify { namespace SDG { namespace SDGEdge {
5182  const char* ControlDependenceType(int64_t);
5183 
5185  std::string ControlDependenceType(int64_t, const std::string &strip);
5186 
5188  const std::vector<int64_t>& ControlDependenceType();
5189 }}}
5190 
5191 namespace Rose {
5192  std::string stringifySDG_SDGEdgeControlDependenceType(int64_t n, const char *strip=NULL, bool canonic=false);
5193  const std::vector<int64_t>& stringifySDG_SDGEdgeControlDependenceType();
5194 }
5195 
5196 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5197 // /src/midend/programAnalysis/genericDataflow/cfgUtils/CallGraphTraverse.h line 124
5198 namespace stringify { namespace CGFunction { namespace iterator {
5200  const char* direction(int64_t);
5201 
5203  std::string direction(int64_t, const std::string &strip);
5204 
5206  const std::vector<int64_t>& direction();
5207 }}}
5208 
5209 namespace Rose {
5210  std::string stringifyCGFunction_iterator_direction(int64_t n, const char *strip=NULL, bool canonic=false);
5211  const std::vector<int64_t>& stringifyCGFunction_iterator_direction();
5212 }
5213 
5214 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5215 // /src/midend/programAnalysis/genericDataflow/lattice/ConstrGraph.h line 45
5216 namespace stringify { namespace ConstrGraph {
5218  const char* levels(int64_t);
5219 
5221  std::string levels(int64_t, const std::string &strip);
5222 
5224  const std::vector<int64_t>& levels();
5225 }}
5226 
5227 namespace Rose {
5228  std::string stringifyConstrGraph_levels(int64_t n, const char *strip=NULL, bool canonic=false);
5229  const std::vector<int64_t>& stringifyConstrGraph_levels();
5230 }
5231 
5232 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5233 // /src/midend/programAnalysis/genericDataflow/simpleAnalyses/taintAnalysis.h line 63
5234 namespace stringify { namespace TaintLattice {
5236  const char* Vertex(int64_t);
5237 
5239  std::string Vertex(int64_t, const std::string &strip);
5240 
5242  const std::vector<int64_t>& Vertex();
5243 }}
5244 
5245 namespace Rose {
5246  std::string stringifyTaintLatticeVertex(int64_t n, const char *strip=NULL, bool canonic=false);
5247  const std::vector<int64_t>& stringifyTaintLatticeVertex();
5248 }
5249 
5250 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5251 // /src/midend/programAnalysis/ssaUnfilteredCfg/reachingDefUnfilteredCfg.h line 19
5252 namespace stringify { namespace ssa_unfiltered_cfg { namespace ReachingDef {
5254  const char* Type(int64_t);
5255 
5257  std::string Type(int64_t, const std::string &strip);
5258 
5260  const std::vector<int64_t>& Type();
5261 }}}
5262 
5263 namespace Rose {
5264  std::string stringify_ssa_unfiltered_cfgReachingDefType(int64_t n, const char *strip=NULL, bool canonic=false);
5265  const std::vector<int64_t>& stringify_ssa_unfiltered_cfgReachingDefType();
5266 }
5267 
5268 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5269 // /src/midend/programAnalysis/dominanceAnalysis/DominatorTree.h line 13
5270 namespace stringify { namespace DominatorTreesAndDominanceFrontiers {
5272  const char* Dir_ection(int64_t);
5273 
5275  std::string Dir_ection(int64_t, const std::string &strip);
5276 
5278  const std::vector<int64_t>& Dir_ection();
5279 }}
5280 
5281 namespace Rose {
5282  std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t n, const char *strip=NULL, bool canonic=false);
5283  const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection();
5284 }
5285 
5286 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5287 // /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 25
5288 namespace stringify { namespace ArithmeticIntensityMeasurement {
5290  const char* running_mode_enum(int64_t);
5291 
5293  std::string running_mode_enum(int64_t, const std::string &strip);
5294 
5296  const std::vector<int64_t>& running_mode_enum();
5297 }}
5298 
5299 namespace Rose {
5300  std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(int64_t n, const char *strip=NULL, bool canonic=false);
5301  const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_running_mode_enum();
5302 }
5303 
5304 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5305 // /src/midend/programAnalysis/arithmeticIntensity/ai_measurement.h line 30
5306 namespace stringify { namespace ArithmeticIntensityMeasurement {
5308  const char* fp_operation_kind_enum(int64_t);
5309 
5311  std::string fp_operation_kind_enum(int64_t, const std::string &strip);
5312 
5314  const std::vector<int64_t>& fp_operation_kind_enum();
5315 }}
5316 
5317 namespace Rose {
5318  std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(int64_t n, const char *strip=NULL, bool canonic=false);
5319  const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum();
5320 }
5321 
5322 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5323 // /src/midend/programAnalysis/dominatorTreesAndDominanceFrontiers/DominatorTree.h line 50
5324 namespace stringify { namespace DominatorTreesAndDominanceFrontiers { namespace DominatorTree {
5326  const char* Direction(int64_t);
5327 
5329  std::string Direction(int64_t, const std::string &strip);
5330 
5332  const std::vector<int64_t>& Direction();
5333 }}}
5334 
5335 namespace Rose {
5336  std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(int64_t n, const char *strip=NULL, bool canonic=false);
5337  const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection();
5338 }
5339 
5340 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5341 // /src/midend/programAnalysis/VirtualFunctionAnalysis/PtrAliasAnalysis.h line 31
5342 namespace stringify { namespace PtrAliasAnalysis {
5344  const char* COLOR(int64_t);
5345 
5347  std::string COLOR(int64_t, const std::string &strip);
5348 
5350  const std::vector<int64_t>& COLOR();
5351 }}
5352 
5353 namespace Rose {
5354  std::string stringifyPtrAliasAnalysisCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
5355  const std::vector<int64_t>& stringifyPtrAliasAnalysisCOLOR();
5356 }
5357 
5358 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5359 // /src/midend/programAnalysis/VirtualFunctionAnalysis/PtrAliasAnalysis.h line 33
5360 namespace stringify { namespace PtrAliasAnalysis {
5362  const char* TRAVERSAL_TYPE(int64_t);
5363 
5365  std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);
5366 
5368  const std::vector<int64_t>& TRAVERSAL_TYPE();
5369 }}
5370 
5371 namespace Rose {
5372  std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
5373  const std::vector<int64_t>& stringifyPtrAliasAnalysisTRAVERSAL_TYPE();
5374 }
5375 
5376 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5377 // /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 280
5378 namespace stringify { namespace CollectAliasRelations {
5380  const char* COLOR(int64_t);
5381 
5383  std::string COLOR(int64_t, const std::string &strip);
5384 
5386  const std::vector<int64_t>& COLOR();
5387 }}
5388 
5389 namespace Rose {
5390  std::string stringifyCollectAliasRelationsCOLOR(int64_t n, const char *strip=NULL, bool canonic=false);
5391  const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR();
5392 }
5393 
5394 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5395 // /src/midend/programAnalysis/VirtualFunctionAnalysis/IntraProcAliasAnalysis.h line 281
5396 namespace stringify { namespace CollectAliasRelations {
5398  const char* TRAVERSAL_TYPE(int64_t);
5399 
5401  std::string TRAVERSAL_TYPE(int64_t, const std::string &strip);
5402 
5404  const std::vector<int64_t>& TRAVERSAL_TYPE();
5405 }}
5406 
5407 namespace Rose {
5408  std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t n, const char *strip=NULL, bool canonic=false);
5409  const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE();
5410 }
5411 
5412 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5413 // /src/roseSupport/transformationSupport.h line 37
5414 namespace stringify { namespace TransformationSupport {
5416  const char* operatorCodeType(int64_t);
5417 
5419  std::string operatorCodeType(int64_t, const std::string &strip);
5420 
5422  const std::vector<int64_t>& operatorCodeType();
5423 }}
5424 
5425 namespace Rose {
5426  std::string stringifyTransformationSupport_operatorCodeType(int64_t n, const char *strip=NULL, bool canonic=false);
5427  const std::vector<int64_t>& stringifyTransformationSupport_operatorCodeType();
5428 }
5429 
5430 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5431 // /src/roseSupport/callbacks.h line 14
5432 namespace stringify { namespace Rose { namespace Callbacks {
5434  const char* Direction(int64_t);
5435 
5437  std::string Direction(int64_t, const std::string &strip);
5438 
5440  const std::vector<int64_t>& Direction();
5441 }}}
5442 
5443 namespace Rose {
5444  std::string stringifyCallbacksDirection(int64_t n, const char *strip=NULL, bool canonic=false);
5445  const std::vector<int64_t>& stringifyCallbacksDirection();
5446 }
5447 
5448 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5449 // /src/roseSupport/utility_functions.C line 1034
5450 namespace stringify {
5452  const char* language_enum(int64_t);
5453 
5455  std::string language_enum(int64_t, const std::string &strip);
5456 
5458  const std::vector<int64_t>& language_enum();
5459 }
5460 
5461 namespace Rose {
5462  std::string stringify_language_enum(int64_t n, const char *strip=NULL, bool canonic=false);
5463  const std::vector<int64_t>& stringify_language_enum();
5464 }
5465 
5466 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5467 // /src/roseExtensions/qtWidgets/AstGraphWidget/DisplayEdge.h line 40
5468 namespace stringify { namespace DisplayEdge {
5470  const char* PaintMode(int64_t);
5471 
5473  std::string PaintMode(int64_t, const std::string &strip);
5474 
5476  const std::vector<int64_t>& PaintMode();
5477 }}
5478 
5479 namespace Rose {
5480  std::string stringifyDisplayEdgePaintMode(int64_t n, const char *strip=NULL, bool canonic=false);
5481  const std::vector<int64_t>& stringifyDisplayEdgePaintMode();
5482 }
5483 
5484 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5485 // /src/roseExtensions/qtWidgets/util/AstDisplayInfo.h line 14
5486 namespace stringify { namespace AstDisplayInfo {
5488  const char* NodeType(int64_t);
5489 
5491  std::string NodeType(int64_t, const std::string &strip);
5492 
5494  const std::vector<int64_t>& NodeType();
5495 }}
5496 
5497 namespace Rose {
5498  std::string stringifyAstDisplayInfoNodeType(int64_t n, const char *strip=NULL, bool canonic=false);
5499  const std::vector<int64_t>& stringifyAstDisplayInfoNodeType();
5500 }
5501 
5502 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5503 // /src/roseExtensions/qtWidgets/ProjectManager/DependencyInfo.h line 20
5504 namespace stringify { namespace DependencyInfo {
5506  const char* State(int64_t);
5507 
5509  std::string State(int64_t, const std::string &strip);
5510 
5512  const std::vector<int64_t>& State();
5513 }}
5514 
5515 namespace Rose {
5516  std::string stringifyDependencyInfoState(int64_t n, const char *strip=NULL, bool canonic=false);
5517  const std::vector<int64_t>& stringifyDependencyInfoState();
5518 }
5519 
5520 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5521 // /src/roseExtensions/qtWidgets/TaskSystem/CompilerOutputWidget.h line 25
5522 namespace stringify { namespace CompilerOutputWidget {
5524  const char* PatternType(int64_t);
5525 
5527  std::string PatternType(int64_t, const std::string &strip);
5528 
5530  const std::vector<int64_t>& PatternType();
5531 }}
5532 
5533 namespace Rose {
5534  std::string stringifyCompilerOutputWidgetPatternType(int64_t n, const char *strip=NULL, bool canonic=false);
5535  const std::vector<int64_t>& stringifyCompilerOutputWidgetPatternType();
5536 }
5537 
5538 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5539 // /src/roseExtensions/qtWidgets/TaskSystem/TaskInterface.h line 25
5540 namespace stringify { namespace Task {
5542  const char* State(int64_t);
5543 
5545  std::string State(int64_t, const std::string &strip);
5546 
5548  const std::vector<int64_t>& State();
5549 }}
5550 
5551 namespace Rose {
5552  std::string stringifyTaskState(int64_t n, const char *strip=NULL, bool canonic=false);
5553  const std::vector<int64_t>& stringifyTaskState();
5554 }
5555 
5556 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5557 // /src/roseExtensions/qtWidgets/QtGradientEditor/qtgradientwidget.cpp line 91
5558 namespace stringify { namespace QtGradientWidgetPrivate {
5560  const char* Handle(int64_t);
5561 
5563  std::string Handle(int64_t, const std::string &strip);
5564 
5566  const std::vector<int64_t>& Handle();
5567 }}
5568 
5569 namespace Rose {
5570  std::string stringifyQtGradientWidgetPrivateHandle(int64_t n, const char *strip=NULL, bool canonic=false);
5571  const std::vector<int64_t>& stringifyQtGradientWidgetPrivateHandle();
5572 }
5573 
5574 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5575 // /src/roseExtensions/qtWidgets/QtGradientEditor/qtcolorline.h line 62
5576 namespace stringify { namespace QtColorLine {
5578  const char* ColorComponent(int64_t);
5579 
5581  std::string ColorComponent(int64_t, const std::string &strip);
5582 
5584  const std::vector<int64_t>& ColorComponent();
5585 }}
5586 
5587 namespace Rose {
5588  std::string stringifyQtColorLineColorComponent(int64_t n, const char *strip=NULL, bool canonic=false);
5589  const std::vector<int64_t>& stringifyQtColorLineColorComponent();
5590 }
5591 
5592 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5593 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 38
5594 namespace stringify { namespace QPanelLayout {
5596  const char* Position(int64_t);
5597 
5599  std::string Position(int64_t, const std::string &strip);
5600 
5602  const std::vector<int64_t>& Position();
5603 }}
5604 
5605 namespace Rose {
5606  std::string stringifyQPanelLayoutPosition(int64_t n, const char *strip=NULL, bool canonic=false);
5607  const std::vector<int64_t>& stringifyQPanelLayoutPosition();
5608 }
5609 
5610 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5611 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qpanellayout.h line 87
5612 namespace stringify { namespace QPanelLayout {
5614  const char* SizeType(int64_t);
5615 
5617  std::string SizeType(int64_t, const std::string &strip);
5618 
5620  const std::vector<int64_t>& SizeType();
5621 }}
5622 
5623 namespace Rose {
5624  std::string stringifyQPanelLayoutSizeType(int64_t n, const char *strip=NULL, bool canonic=false);
5625  const std::vector<int64_t>& stringifyQPanelLayoutSizeType();
5626 }
5627 
5628 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5629 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 41
5630 namespace stringify { namespace QNFAAction {
5632  const char* QNFAAction_(int64_t);
5633 
5635  std::string QNFAAction_(int64_t, const std::string &strip);
5636 
5638  const std::vector<int64_t>& QNFAAction_();
5639 }}
5640 
5641 namespace Rose {
5642  std::string stringifyQNFAActionQNFAAction_(int64_t n, const char *strip=NULL, bool canonic=false);
5643  const std::vector<int64_t>& stringifyQNFAActionQNFAAction_();
5644 }
5645 
5646 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5647 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfadefinition.h line 129
5648 namespace stringify { namespace QNFADefinition { namespace PMatch {
5650  const char* Type(int64_t);
5651 
5653  std::string Type(int64_t, const std::string &strip);
5654 
5656  const std::vector<int64_t>& Type();
5657 }}}
5658 
5659 namespace Rose {
5660  std::string stringifyQNFADefinitionPMatchType(int64_t n, const char *strip=NULL, bool canonic=false);
5661  const std::vector<int64_t>& stringifyQNFADefinitionPMatchType();
5662 }
5663 
5664 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5665 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 42
5666 namespace stringify {
5668  const char* NFAType(int64_t);
5669 
5671  std::string NFAType(int64_t, const std::string &strip);
5672 
5674  const std::vector<int64_t>& NFAType();
5675 }
5676 
5677 namespace Rose {
5678  std::string stringifyNFAType(int64_t n, const char *strip=NULL, bool canonic=false);
5679  const std::vector<int64_t>& stringifyNFAType();
5680 }
5681 
5682 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5683 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qnfa/qnfa.h line 63
5684 namespace stringify {
5686  const char* NFAAssertion(int64_t);
5687 
5689  std::string NFAAssertion(int64_t, const std::string &strip);
5690 
5692  const std::vector<int64_t>& NFAAssertion();
5693 }
5694 
5695 namespace Rose {
5696  std::string stringifyNFAAssertion(int64_t n, const char *strip=NULL, bool canonic=false);
5697  const std::vector<int64_t>& stringifyNFAAssertion();
5698 }
5699 
5700 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5701 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qreliablefilewatch.h line 52
5702 namespace stringify { namespace QReliableFileWatch {
5704  const char* State(int64_t);
5705 
5707  std::string State(int64_t, const std::string &strip);
5708 
5710  const std::vector<int64_t>& State();
5711 }}
5712 
5713 namespace Rose {
5714  std::string stringifyQReliableFileWatchState(int64_t n, const char *strip=NULL, bool canonic=false);
5715  const std::vector<int64_t>& stringifyQReliableFileWatchState();
5716 }
5717 
5718 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5719 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 39
5720 namespace stringify { namespace QDocumentCursor {
5722  const char* MoveFlag(int64_t);
5723 
5725  std::string MoveFlag(int64_t, const std::string &strip);
5726 
5728  const std::vector<int64_t>& MoveFlag();
5729 }}
5730 
5731 namespace Rose {
5732  std::string stringifyQDocumentCursorMoveFlag(int64_t n, const char *strip=NULL, bool canonic=false);
5733  const std::vector<int64_t>& stringifyQDocumentCursorMoveFlag();
5734 }
5735 
5736 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5737 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 48
5738 namespace stringify { namespace QDocumentCursor {
5740  const char* MoveOperation(int64_t);
5741 
5743  std::string MoveOperation(int64_t, const std::string &strip);
5744 
5746  const std::vector<int64_t>& MoveOperation();
5747 }}
5748 
5749 namespace Rose {
5750  std::string stringifyQDocumentCursorMoveOperation(int64_t n, const char *strip=NULL, bool canonic=false);
5751  const std::vector<int64_t>& stringifyQDocumentCursorMoveOperation();
5752 }
5753 
5754 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5755 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor.h line 75
5756 namespace stringify { namespace QDocumentCursor {
5758  const char* SelectionType(int64_t);
5759 
5761  std::string SelectionType(int64_t, const std::string &strip);
5762 
5764  const std::vector<int64_t>& SelectionType();
5765 }}
5766 
5767 namespace Rose {
5768  std::string stringifyQDocumentCursorSelectionType(int64_t n, const char *strip=NULL, bool canonic=false);
5769  const std::vector<int64_t>& stringifyQDocumentCursorSelectionType();
5770 }
5771 
5772 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5773 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 38
5774 namespace stringify { namespace QParenthesis {
5776  const char* Role(int64_t);
5777 
5779  std::string Role(int64_t, const std::string &strip);
5780 
5782  const std::vector<int64_t>& Role();
5783 }}
5784 
5785 namespace Rose {
5786  std::string stringifyQParenthesisRole(int64_t n, const char *strip=NULL, bool canonic=false);
5787  const std::vector<int64_t>& stringifyQParenthesisRole();
5788 }
5789 
5790 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5791 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentline.h line 69
5792 namespace stringify { namespace QDocumentLine {
5794  const char* State(int64_t);
5795 
5797  std::string State(int64_t, const std::string &strip);
5798 
5800  const std::vector<int64_t>& State();
5801 }}
5802 
5803 namespace Rose {
5804  std::string stringifyQDocumentLineState(int64_t n, const char *strip=NULL, bool canonic=false);
5805  const std::vector<int64_t>& stringifyQDocumentLineState();
5806 }
5807 
5808 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5809 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 84
5810 namespace stringify { namespace QDocument {
5812  const char* LineEnding(int64_t);
5813 
5815  std::string LineEnding(int64_t, const std::string &strip);
5816 
5818  const std::vector<int64_t>& LineEnding();
5819 }}
5820 
5821 namespace Rose {
5822  std::string stringifyQDocumentLineEnding(int64_t n, const char *strip=NULL, bool canonic=false);
5823  const std::vector<int64_t>& stringifyQDocumentLineEnding();
5824 }
5825 
5826 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5827 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 93
5828 namespace stringify { namespace QDocument {
5830  const char* TextProcessing(int64_t);
5831 
5833  std::string TextProcessing(int64_t, const std::string &strip);
5834 
5836  const std::vector<int64_t>& TextProcessing();
5837 }}
5838 
5839 namespace Rose {
5840  std::string stringifyQDocumentTextProcessing(int64_t n, const char *strip=NULL, bool canonic=false);
5841  const std::vector<int64_t>& stringifyQDocumentTextProcessing();
5842 }
5843 
5844 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5845 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocument.h line 100
5846 namespace stringify { namespace QDocument {
5848  const char* WhiteSpaceFlag(int64_t);
5849 
5851  std::string WhiteSpaceFlag(int64_t, const std::string &strip);
5852 
5854  const std::vector<int64_t>& WhiteSpaceFlag();
5855 }}
5856 
5857 namespace Rose {
5858  std::string stringifyQDocumentWhiteSpaceFlag(int64_t n, const char *strip=NULL, bool canonic=false);
5859  const std::vector<int64_t>& stringifyQDocumentWhiteSpaceFlag();
5860 }
5861 
5862 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5863 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentsearch.h line 40
5864 namespace stringify { namespace QDocumentSearch {
5866  const char* Option(int64_t);
5867 
5869  std::string Option(int64_t, const std::string &strip);
5870 
5872  const std::vector<int64_t>& Option();
5873 }}
5874 
5875 namespace Rose {
5876  std::string stringifyQDocumentSearchOption(int64_t n, const char *strip=NULL, bool canonic=false);
5877  const std::vector<int64_t>& stringifyQDocumentSearchOption();
5878 }
5879 
5880 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5881 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcommand.h line 37
5882 namespace stringify { namespace QDocumentCommand {
5884  const char* Command(int64_t);
5885 
5887  std::string Command(int64_t, const std::string &strip);
5888 
5890  const std::vector<int64_t>& Command();
5891 }}
5892 
5893 namespace Rose {
5894  std::string stringifyQDocumentCommandCommand(int64_t n, const char *strip=NULL, bool canonic=false);
5895  const std::vector<int64_t>& stringifyQDocumentCommandCommand();
5896 }
5897 
5898 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5899 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/document/qdocumentcursor_p.h line 52
5900 namespace stringify { namespace QDocumentCursorHandle {
5902  const char* Flags(int64_t);
5903 
5905  std::string Flags(int64_t, const std::string &strip);
5906 
5908  const std::vector<int64_t>& Flags();
5909 }}
5910 
5911 namespace Rose {
5912  std::string stringifyQDocumentCursorHandleFlags(int64_t n, const char *strip=NULL, bool canonic=false);
5913  const std::vector<int64_t>& stringifyQDocumentCursorHandleFlags();
5914 }
5915 
5916 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5917 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qlanguagedefinition.h line 44
5918 namespace stringify { namespace QLanguageDefinition {
5920  const char* CollapseFlag(int64_t);
5921 
5923  std::string CollapseFlag(int64_t, const std::string &strip);
5924 
5926  const std::vector<int64_t>& CollapseFlag();
5927 }}
5928 
5929 namespace Rose {
5930  std::string stringifyQLanguageDefinitionCollapseFlag(int64_t n, const char *strip=NULL, bool canonic=false);
5931  const std::vector<int64_t>& stringifyQLanguageDefinitionCollapseFlag();
5932 }
5933 
5934 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5935 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 64
5936 namespace stringify { namespace QEditor {
5938  const char* CodecUpdatePolicy(int64_t);
5939 
5941  std::string CodecUpdatePolicy(int64_t, const std::string &strip);
5942 
5944  const std::vector<int64_t>& CodecUpdatePolicy();
5945 }}
5946 
5947 namespace Rose {
5948  std::string stringifyQEditorCodecUpdatePolicy(int64_t n, const char *strip=NULL, bool canonic=false);
5949  const std::vector<int64_t>& stringifyQEditorCodecUpdatePolicy();
5950 }
5951 
5952 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5953 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 74
5954 namespace stringify { namespace QEditor {
5956  const char* EditFlag(int64_t);
5957 
5959  std::string EditFlag(int64_t, const std::string &strip);
5960 
5962  const std::vector<int64_t>& EditFlag();
5963 }}
5964 
5965 namespace Rose {
5966  std::string stringifyQEditorEditFlag(int64_t n, const char *strip=NULL, bool canonic=false);
5967  const std::vector<int64_t>& stringifyQEditorEditFlag();
5968 }
5969 
5970 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5971 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qeditor.h line 493
5972 namespace stringify { namespace QEditor {
5974  const char* SaveState(int64_t);
5975 
5977  std::string SaveState(int64_t, const std::string &strip);
5978 
5980  const std::vector<int64_t>& SaveState();
5981 }}
5982 
5983 namespace Rose {
5984  std::string stringifyQEditorSaveState(int64_t n, const char *strip=NULL, bool canonic=false);
5985  const std::vector<int64_t>& stringifyQEditorSaveState();
5986 }
5987 
5988 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
5989 // /src/roseExtensions/qtWidgets/QCodeEditWidget/QCodeEdit/qcodeedit.h line 46
5990 namespace stringify { namespace QCodeEdit {
5992  const char* Position(int64_t);
5993 
5995  std::string Position(int64_t, const std::string &strip);
5996 
5998  const std::vector<int64_t>& Position();
5999 }}
6000 
6001 namespace Rose {
6002  std::string stringifyQCodeEditPosition(int64_t n, const char *strip=NULL, bool canonic=false);
6003  const std::vector<int64_t>& stringifyQCodeEditPosition();
6004 }
6005 
6006 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6007 // /src/roseExtensions/failSafe/failSafePragma.h line 31
6008 namespace stringify { namespace FailSafe {
6010  const char* fail_safe_enum(int64_t);
6011 
6013  std::string fail_safe_enum(int64_t, const std::string &strip);
6014 
6016  const std::vector<int64_t>& fail_safe_enum();
6017 }}
6018 
6019 namespace Rose {
6020  std::string stringifyFailSafe_fail_safe_enum(int64_t n, const char *strip=NULL, bool canonic=false);
6021  const std::vector<int64_t>& stringifyFailSafe_fail_safe_enum();
6022 }
6023 
6024 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6025 // /src/roseExtensions/dataStructureTraversal/GenRepresentation.h line 23
6026 namespace stringify { namespace GenRepresentation {
6028  const char* TypeOfPrint(int64_t);
6029 
6031  std::string TypeOfPrint(int64_t, const std::string &strip);
6032 
6034  const std::vector<int64_t>& TypeOfPrint();
6035 }}
6036 
6037 namespace Rose {
6038  std::string stringifyGenRepresentationTypeOfPrint(int64_t n, const char *strip=NULL, bool canonic=false);
6039  const std::vector<int64_t>& stringifyGenRepresentationTypeOfPrint();
6040 }
6041 
6042 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6043 // /src/roseExtensions/dataStructureTraversal/exampleTest.C line 3
6044 namespace stringify {
6046  const char* controlEnum(int64_t);
6047 
6049  std::string controlEnum(int64_t, const std::string &strip);
6050 
6052  const std::vector<int64_t>& controlEnum();
6053 }
6054 
6055 namespace Rose {
6056  std::string stringify_controlEnum(int64_t n, const char *strip=NULL, bool canonic=false);
6057  const std::vector<int64_t>& stringify_controlEnum();
6058 }
6059 
6060 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6061 // /src/backend/asmUnparser/AsmUnparser.h line 258
6062 namespace stringify { namespace Rose { namespace BinaryAnalysis { namespace AsmUnparser {
6064  const char* Organization(int64_t);
6065 
6067  std::string Organization(int64_t, const std::string &strip);
6068 
6070  const std::vector<int64_t>& Organization();
6071 }}}}
6072 
6073 namespace Rose {
6074  std::string stringifyBinaryAnalysisAsmUnparserOrganization(int64_t n, const char *strip=NULL, bool canonic=false);
6075  const std::vector<int64_t>& stringifyBinaryAnalysisAsmUnparserOrganization();
6076 }
6077 
6078 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6079 // /src/backend/unparser/unparser.h line 205
6080 namespace stringify { namespace Unparser {
6082  const char* token_sequence_position_enum_type(int64_t);
6083 
6085  std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
6086 
6088  const std::vector<int64_t>& token_sequence_position_enum_type();
6089 }}
6090 
6091 namespace Rose {
6092  std::string stringifyUnparser_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
6093  const std::vector<int64_t>& stringifyUnparser_token_sequence_position_enum_type();
6094 }
6095 
6096 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6097 // /src/backend/unparser/CxxCodeGeneration/unparseCxx.h line 543
6098 namespace stringify { namespace Unparse_ExprStmt {
6100  const char* token_sequence_position_enum_type(int64_t);
6101 
6103  std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
6104 
6106  const std::vector<int64_t>& token_sequence_position_enum_type();
6107 }}
6108 
6109 namespace Rose {
6110  std::string stringifyUnparse_ExprStmt_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
6111  const std::vector<int64_t>& stringifyUnparse_ExprStmt_token_sequence_position_enum_type();
6112 }
6113 
6114 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6115 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 19
6116 namespace stringify {
6118  const char* AssociativitySpecifier(int64_t);
6119 
6121  std::string AssociativitySpecifier(int64_t, const std::string &strip);
6122 
6124  const std::vector<int64_t>& AssociativitySpecifier();
6125 }
6126 
6127 namespace Rose {
6128  std::string stringifyAssociativitySpecifier(int64_t n, const char *strip=NULL, bool canonic=false);
6129  const std::vector<int64_t>& stringifyAssociativitySpecifier();
6130 }
6131 
6132 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6133 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 46
6134 namespace stringify { namespace UnparseLanguageIndependentConstructs {
6136  const char* token_sequence_position_enum_type(int64_t);
6137 
6139  std::string token_sequence_position_enum_type(int64_t, const std::string &strip);
6140 
6142  const std::vector<int64_t>& token_sequence_position_enum_type();
6143 }}
6144 
6145 namespace Rose {
6146  std::string stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
6147  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_token_sequence_position_enum_type();
6148 }
6149 
6150 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6151 // /src/backend/unparser/languageIndependenceSupport/unparseLanguageIndependentConstructs.h line 74
6152 namespace stringify { namespace UnparseLanguageIndependentConstructs {
6154  const char* unparsed_as_enum_type(int64_t);
6155 
6157  std::string unparsed_as_enum_type(int64_t, const std::string &strip);
6158 
6160  const std::vector<int64_t>& unparsed_as_enum_type();
6161 }}
6162 
6163 namespace Rose {
6164  std::string stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type(int64_t n, const char *strip=NULL, bool canonic=false);
6165  const std::vector<int64_t>& stringifyUnparseLanguageIndependentConstructs_unparsed_as_enum_type();
6166 }
6167 
6168 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6169 // /src/backend/unparser/formatSupport/unparse_format.h line 51
6170 namespace stringify {
6172  const char* Format_Opt(int64_t);
6173 
6175  std::string Format_Opt(int64_t, const std::string &strip);
6176 
6178  const std::vector<int64_t>& Format_Opt();
6179 }
6180 
6181 namespace Rose {
6182  std::string stringifyFormat_Opt(int64_t n, const char *strip=NULL, bool canonic=false);
6183  const std::vector<int64_t>& stringifyFormat_Opt();
6184 }
6185 
6186 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6187 // /src/frontend/Experimental_Jovial_ROSE_Connection/preprocess.C line 30
6188 namespace stringify { namespace Jovial {
6190  const char* State(int64_t);
6191 
6193  std::string State(int64_t, const std::string &strip);
6194 
6196  const std::vector<int64_t>& State();
6197 }}
6198 
6199 namespace Rose {
6200  std::string stringifyJovialState(int64_t n, const char *strip=NULL, bool canonic=false);
6201  const std::vector<int64_t>& stringifyJovialState();
6202 }
6203 
6204 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6205 // /src/frontend/Experimental_Jovial_ROSE_Connection/Jovial_to_ROSE_translation.h line 11
6206 namespace stringify { namespace Jovial_ROSE_Translation {
6208  const char* ExpressionKind(int64_t);
6209 
6211  std::string ExpressionKind(int64_t, const std::string &strip);
6212 
6214  const std::vector<int64_t>& ExpressionKind();
6215 }}
6216 
6217 namespace Rose {
6218  std::string stringifyJovial_ROSE_TranslationExpressionKind(int64_t n, const char *strip=NULL, bool canonic=false);
6219  const std::vector<int64_t>& stringifyJovial_ROSE_TranslationExpressionKind();
6220 }
6221 
6222 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6223 // /src/frontend/BinaryFormats/ByteOrder.h line 10
6224 namespace stringify { namespace ByteOrder {
6226  const char* Endianness(int64_t);
6227 
6229  std::string Endianness(int64_t, const std::string &strip);
6230 
6232  const std::vector<int64_t>& Endianness();
6233 }}
6234 
6235 namespace Rose {
6236  std::string stringifyByteOrderEndianness(int64_t n, const char *strip=NULL, bool canonic=false);
6237  const std::vector<int64_t>& stringifyByteOrderEndianness();
6238 }
6239 
6240 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6241 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 47
6242 namespace stringify {
6244  const char* Element_Kinds(int64_t);
6245 
6247  std::string Element_Kinds(int64_t, const std::string &strip);
6248 
6250  const std::vector<int64_t>& Element_Kinds();
6251 }
6252 
6253 namespace Rose {
6254  std::string stringifyElement_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6255  const std::vector<int64_t>& stringifyElement_Kinds();
6256 }
6257 
6258 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6259 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 142
6260 namespace stringify {
6262  const char* Operator_Kinds(int64_t);
6263 
6265  std::string Operator_Kinds(int64_t, const std::string &strip);
6266 
6268  const std::vector<int64_t>& Operator_Kinds();
6269 }
6270 
6271 namespace Rose {
6272  std::string stringifyOperator_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6273  const std::vector<int64_t>& stringifyOperator_Kinds();
6274 }
6275 
6276 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6277 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 172
6278 namespace stringify {
6280  const char* Pragma_Kinds(int64_t);
6281 
6283  std::string Pragma_Kinds(int64_t, const std::string &strip);
6284 
6286  const std::vector<int64_t>& Pragma_Kinds();
6287 }
6288 
6289 namespace Rose {
6290  std::string stringifyPragma_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6291  const std::vector<int64_t>& stringifyPragma_Kinds();
6292 }
6293 
6294 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6295 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 246
6296 namespace stringify {
6298  const char* Defining_Name_Kinds(int64_t);
6299 
6301  std::string Defining_Name_Kinds(int64_t, const std::string &strip);
6302 
6304  const std::vector<int64_t>& Defining_Name_Kinds();
6305 }
6306 
6307 namespace Rose {
6308  std::string stringifyDefining_Name_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6309  const std::vector<int64_t>& stringifyDefining_Name_Kinds();
6310 }
6311 
6312 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6313 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 287
6314 namespace stringify {
6316  const char* Declaration_Kinds(int64_t);
6317 
6319  std::string Declaration_Kinds(int64_t, const std::string &strip);
6320 
6322  const std::vector<int64_t>& Declaration_Kinds();
6323 }
6324 
6325 namespace Rose {
6326  std::string stringifyDeclaration_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6327  const std::vector<int64_t>& stringifyDeclaration_Kinds();
6328 }
6329 
6330 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6331 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 391
6332 namespace stringify {
6334  const char* Declaration_Origins(int64_t);
6335 
6337  std::string Declaration_Origins(int64_t, const std::string &strip);
6338 
6340  const std::vector<int64_t>& Declaration_Origins();
6341 }
6342 
6343 namespace Rose {
6344  std::string stringifyDeclaration_Origins(int64_t n, const char *strip=NULL, bool canonic=false);
6345  const std::vector<int64_t>& stringifyDeclaration_Origins();
6346 }
6347 
6348 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6349 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 407
6350 namespace stringify {
6352  const char* Mode_Kinds(int64_t);
6353 
6355  std::string Mode_Kinds(int64_t, const std::string &strip);
6356 
6358  const std::vector<int64_t>& Mode_Kinds();
6359 }
6360 
6361 namespace Rose {
6362  std::string stringifyMode_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6363  const std::vector<int64_t>& stringifyMode_Kinds();
6364 }
6365 
6366 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6367 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 417
6368 namespace stringify {
6370  const char* Subprogram_Default_Kinds(int64_t);
6371 
6373  std::string Subprogram_Default_Kinds(int64_t, const std::string &strip);
6374 
6376  const std::vector<int64_t>& Subprogram_Default_Kinds();
6377 }
6378 
6379 namespace Rose {
6380  std::string stringifySubprogram_Default_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6381  const std::vector<int64_t>& stringifySubprogram_Default_Kinds();
6382 }
6383 
6384 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6385 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 813
6386 namespace stringify {
6388  const char* Definition_Kinds(int64_t);
6389 
6391  std::string Definition_Kinds(int64_t, const std::string &strip);
6392 
6394  const std::vector<int64_t>& Definition_Kinds();
6395 }
6396 
6397 namespace Rose {
6398  std::string stringifyDefinition_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6399  const std::vector<int64_t>& stringifyDefinition_Kinds();
6400 }
6401 
6402 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6403 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 846
6404 namespace stringify {
6406  const char* _Type_Kinds(int64_t);
6407 
6409  std::string _Type_Kinds(int64_t, const std::string &strip);
6410 
6412  const std::vector<int64_t>& _Type_Kinds();
6413 }
6414 
6415 namespace Rose {
6416  std::string stringify_Type_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6417  const std::vector<int64_t>& stringify_Type_Kinds();
6418 }
6419 
6420 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6421 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 870
6422 namespace stringify {
6424  const char* _Constraint_Kinds(int64_t);
6425 
6427  std::string _Constraint_Kinds(int64_t, const std::string &strip);
6428 
6430  const std::vector<int64_t>& _Constraint_Kinds();
6431 }
6432 
6433 namespace Rose {
6434  std::string stringify_Constraint_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6435  const std::vector<int64_t>& stringify_Constraint_Kinds();
6436 }
6437 
6438 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6439 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 880
6440 namespace stringify {
6442  const char* _Interface_Kinds(int64_t);
6443 
6445  std::string _Interface_Kinds(int64_t, const std::string &strip);
6446 
6448  const std::vector<int64_t>& _Interface_Kinds();
6449 }
6450 
6451 namespace Rose {
6452  std::string stringify_Interface_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6453  const std::vector<int64_t>& stringify_Interface_Kinds();
6454 }
6455 
6456 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6457 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 889
6458 namespace stringify {
6460  const char* _Root_Type_Kinds(int64_t);
6461 
6463  std::string _Root_Type_Kinds(int64_t, const std::string &strip);
6464 
6466  const std::vector<int64_t>& _Root_Type_Kinds();
6467 }
6468 
6469 namespace Rose {
6470  std::string stringify_Root_Type_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6471  const std::vector<int64_t>& stringify_Root_Type_Kinds();
6472 }
6473 
6474 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6475 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 898
6476 namespace stringify {
6478  const char* _Discrete_Range_Kinds(int64_t);
6479 
6481  std::string _Discrete_Range_Kinds(int64_t, const std::string &strip);
6482 
6484  const std::vector<int64_t>& _Discrete_Range_Kinds();
6485 }
6486 
6487 namespace Rose {
6488  std::string stringify_Discrete_Range_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6489  const std::vector<int64_t>& stringify_Discrete_Range_Kinds();
6490 }
6491 
6492 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6493 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 905
6494 namespace stringify {
6496  const char* _Formal_Type_Kinds(int64_t);
6497 
6499  std::string _Formal_Type_Kinds(int64_t, const std::string &strip);
6500 
6502  const std::vector<int64_t>& _Formal_Type_Kinds();
6503 }
6504 
6505 namespace Rose {
6506  std::string stringify_Formal_Type_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6507  const std::vector<int64_t>& stringify_Formal_Type_Kinds();
6508 }
6509 
6510 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6511 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 927
6512 namespace stringify {
6514  const char* _Access_Type_Kinds(int64_t);
6515 
6517  std::string _Access_Type_Kinds(int64_t, const std::string &strip);
6518 
6520  const std::vector<int64_t>& _Access_Type_Kinds();
6521 }
6522 
6523 namespace Rose {
6524  std::string stringify_Access_Type_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6525  const std::vector<int64_t>& stringify_Access_Type_Kinds();
6526 }
6527 
6528 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6529 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 938
6530 namespace stringify {
6532  const char* _Access_Definition_Kinds(int64_t);
6533 
6535  std::string _Access_Definition_Kinds(int64_t, const std::string &strip);
6536 
6538  const std::vector<int64_t>& _Access_Definition_Kinds();
6539 }
6540 
6541 namespace Rose {
6542  std::string stringify_Access_Definition_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6543  const std::vector<int64_t>& stringify_Access_Definition_Kinds();
6544 }
6545 
6546 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6547 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1273
6548 namespace stringify {
6550  const char* Expression_Kinds(int64_t);
6551 
6553  std::string Expression_Kinds(int64_t, const std::string &strip);
6554 
6556  const std::vector<int64_t>& Expression_Kinds();
6557 }
6558 
6559 namespace Rose {
6560  std::string stringifyExpression_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6561  const std::vector<int64_t>& stringifyExpression_Kinds();
6562 }
6563 
6564 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6565 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1318
6566 namespace stringify {
6568  const char* Attribute_Kinds(int64_t);
6569 
6571  std::string Attribute_Kinds(int64_t, const std::string &strip);
6572 
6574  const std::vector<int64_t>& Attribute_Kinds();
6575 }
6576 
6577 namespace Rose {
6578  std::string stringifyAttribute_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6579  const std::vector<int64_t>& stringifyAttribute_Kinds();
6580 }
6581 
6582 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6583 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1544
6584 namespace stringify {
6586  const char* Association_Kinds(int64_t);
6587 
6589  std::string Association_Kinds(int64_t, const std::string &strip);
6590 
6592  const std::vector<int64_t>& Association_Kinds();
6593 }
6594 
6595 namespace Rose {
6596  std::string stringifyAssociation_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6597  const std::vector<int64_t>& stringifyAssociation_Kinds();
6598 }
6599 
6600 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6601 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1593
6602 namespace stringify {
6604  const char* Statement_Kinds(int64_t);
6605 
6607  std::string Statement_Kinds(int64_t, const std::string &strip);
6608 
6610  const std::vector<int64_t>& Statement_Kinds();
6611 }
6612 
6613 namespace Rose {
6614  std::string stringifyStatement_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6615  const std::vector<int64_t>& stringifyStatement_Kinds();
6616 }
6617 
6618 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6619 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_nodes.h line 1741
6620 namespace stringify {
6622  const char* Path_Kinds(int64_t);
6623 
6625  std::string Path_Kinds(int64_t, const std::string &strip);
6626 
6628  const std::vector<int64_t>& Path_Kinds();
6629 }
6630 
6631 namespace Rose {
6632  std::string stringifyPath_Kinds(int64_t n, const char *strip=NULL, bool canonic=false);
6633  const std::vector<int64_t>& stringifyPath_Kinds();
6634 }
6635 
6636 // DO NOT EDIT -- This implementation was automatically generated for the enum defined at
6637 // /src/frontend/Experimental_Ada_ROSE_Connection/parser/a_nodes/include/a_no