1 #include <boost/algorithm/string/predicate.hpp>
2 #include <boost/lexical_cast.hpp>
11 case 0L:
return "e_unknown";
12 case 1L:
return "e_constructor";
13 case 2L:
return "e_destructor";
14 case 3L:
return "e_copy_constructor";
15 case 4L:
return "e_assignment_operator";
16 case 5L:
return "e_last_type";
24 s =
"(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
25 if (boost::starts_with(s, strip))
26 s = s.substr(strip.size());
31 static const int64_t values[] = {
39 static const std::vector<int64_t> retval(values, values + 6);
46 std::string stringify_defaultEnumFunctionType(int64_t i,
const char *strip,
bool canonic) {
49 retval =
"(defaultEnumFunctionType)" + boost::lexical_cast<std::string>(i);
51 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
52 retval = retval.substr(strlen(strip));
54 retval =
"defaultEnumFunctionType::" + retval;
59 const std::vector<int64_t>& stringify_defaultEnumFunctionType() {
69 case 0L:
return "INSERT_BEFORE";
70 case 1L:
return "APPEND_SCOPE";
71 case 2L:
return "INVALID";
79 s =
"(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
80 if (boost::starts_with(s, strip))
81 s = s.substr(strip.size());
86 static const int64_t values[] = {
91 static const std::vector<int64_t> retval(values, values + 3);
98 std::string stringifyFunctionCallInfoInsertionMode(int64_t i,
const char *strip,
bool canonic) {
100 if (retval.empty()) {
101 retval =
"(FunctionCallInfo::InsertionMode)" + boost::lexical_cast<std::string>(i);
103 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
104 retval = retval.substr(strlen(strip));
106 retval =
"FunctionCallInfo::InsertionMode::" + retval;
111 const std::vector<int64_t>& stringifyFunctionCallInfoInsertionMode() {
121 case 0L:
return "e_gomp";
122 case 1L:
return "e_omni";
123 case 2L:
return "e_last_rtl";
131 s =
"(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
132 if (boost::starts_with(s, strip))
133 s = s.substr(strip.size());
138 static const int64_t values[] = {
143 static const std::vector<int64_t> retval(values, values + 3);
150 std::string stringifyOmpSupport_omp_rtl_enum(int64_t i,
const char *strip,
bool canonic) {
152 if (retval.empty()) {
153 retval =
"(OmpSupport::omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
155 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
156 retval = retval.substr(strlen(strip));
158 retval =
"OmpSupport::omp_rtl_enum::" + retval;
163 const std::vector<int64_t>& stringifyOmpSupport_omp_rtl_enum() {
173 case 0L:
return "e_undefined";
174 case 1L:
return "e_gomp";
175 case 2L:
return "e_omni";
176 case 3L:
return "e_last_rtl";
184 s =
"(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
185 if (boost::starts_with(s, strip))
186 s = s.substr(strip.size());
191 static const int64_t values[] = {
197 static const std::vector<int64_t> retval(values, values + 4);
204 std::string stringify_omp_rtl_enum(int64_t i,
const char *strip,
bool canonic) {
206 if (retval.empty()) {
207 retval =
"(omp_rtl_enum)" + boost::lexical_cast<std::string>(i);
209 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
210 retval = retval.substr(strlen(strip));
212 retval =
"omp_rtl_enum::" + retval;
217 const std::vector<int64_t>& stringify_omp_rtl_enum() {
227 case 0L:
return "UNKNOWN";
228 case 1L:
return "COMBINE";
229 case 2L:
return "REPLACE";
230 case 3L:
return "NO_ADD";
238 s =
"(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
239 if (boost::starts_with(s, strip))
240 s = s.substr(strip.size());
245 static const int64_t values[] = {
251 static const std::vector<int64_t> retval(values, values + 4);
258 std::string stringifyLibraryIdentificationDUPLICATE_OPTION(int64_t i,
const char *strip,
bool canonic) {
260 if (retval.empty()) {
261 retval =
"(LibraryIdentification::DUPLICATE_OPTION)" + boost::lexical_cast<std::string>(i);
263 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
264 retval = retval.substr(strlen(strip));
266 retval =
"LibraryIdentification::DUPLICATE_OPTION::" + retval;
271 const std::vector<int64_t>& stringifyLibraryIdentificationDUPLICATE_OPTION() {
281 case 0L:
return "NONE";
282 case 1L:
return "LTPAREN";
283 case 2L:
return "RTPAREN";
284 case 3L:
return "BITVECTOR";
285 case 4L:
return "SYMBOL";
290 std::string
Type(int64_t i,
const std::string &strip) {
291 std::string s =
Type(i);
293 s =
"(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
294 if (boost::starts_with(s, strip))
295 s = s.substr(strip.size());
299 const std::vector<int64_t>&
Type() {
300 static const int64_t values[] = {
307 static const std::vector<int64_t> retval(values, values + 5);
314 std::string stringifyBinaryAnalysisSymbolicExprParserTokenType(int64_t i,
const char *strip,
bool canonic) {
316 if (retval.empty()) {
317 retval =
"(Rose::BinaryAnalysis::SymbolicExprParser::Token::Type)" + boost::lexical_cast<std::string>(i);
319 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
320 retval = retval.substr(strlen(strip));
322 retval =
"Rose::BinaryAnalysis::SymbolicExprParser::Token::Type::" + retval;
327 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprParserTokenType() {
334 namespace stringify {
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
namespace InputVariables {
namespace Variable {
337 case 0L:
return "INVALID";
338 case 1L:
return "PROGRAM_ARGUMENT_COUNT";
339 case 2L:
return "PROGRAM_ARGUMENT";
340 case 3L:
return "ENVIRONMENT";
341 case 4L:
return "SYSTEM_CALL_RETVAL";
346 std::string
Whence(int64_t i,
const std::string &strip) {
347 std::string s =
Whence(i);
349 s =
"(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
350 if (boost::starts_with(s, strip))
351 s = s.substr(strip.size());
356 static const int64_t values[] = {
363 static const std::vector<int64_t> retval(values, values + 5);
370 std::string stringifyBinaryAnalysisConcolicInputVariablesVariableWhence(int64_t i,
const char *strip,
bool canonic) {
372 if (retval.empty()) {
373 retval =
"(Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence)" + boost::lexical_cast<std::string>(i);
375 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
376 retval = retval.substr(strlen(strip));
378 retval =
"Rose::BinaryAnalysis::Concolic::InputVariables::Variable::Whence::" + retval;
383 const std::vector<int64_t>& stringifyBinaryAnalysisConcolicInputVariablesVariableWhence() {
393 case 0L:
return "NO";
394 case 1L:
return "YES";
399 std::string
Flag(int64_t i,
const std::string &strip) {
400 std::string s =
Flag(i);
402 s =
"(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
403 if (boost::starts_with(s, strip))
404 s = s.substr(strip.size());
408 const std::vector<int64_t>&
Flag() {
409 static const int64_t values[] = {
413 static const std::vector<int64_t> retval(values, values + 2);
420 std::string stringifyBinaryAnalysisConcolicUpdateFlag(int64_t i,
const char *strip,
bool canonic) {
422 if (retval.empty()) {
423 retval =
"(Rose::BinaryAnalysis::Concolic::Update::Flag)" + boost::lexical_cast<std::string>(i);
425 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
426 retval = retval.substr(strlen(strip));
428 retval =
"Rose::BinaryAnalysis::Concolic::Update::Flag::" + retval;
433 const std::vector<int64_t>& stringifyBinaryAnalysisConcolicUpdateFlag() {
443 case 1L:
return "ADDR2SRC";
444 case 2L:
return "SRC2ADDR";
445 case 3L:
return "BIDIRECTIONAL";
450 std::string
Direction(int64_t i,
const std::string &strip) {
453 s =
"(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
454 if (boost::starts_with(s, strip))
455 s = s.substr(strip.size());
460 static const int64_t values[] = {
465 static const std::vector<int64_t> retval(values, values + 3);
472 std::string stringifyBinaryAnalysisDwarfLineMapperDirection(int64_t i,
const char *strip,
bool canonic) {
474 if (retval.empty()) {
475 retval =
"(Rose::BinaryAnalysis::DwarfLineMapper::Direction)" + boost::lexical_cast<std::string>(i);
477 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
478 retval = retval.substr(strlen(strip));
480 retval =
"Rose::BinaryAnalysis::DwarfLineMapper::Direction::" + retval;
485 const std::vector<int64_t>& stringifyBinaryAnalysisDwarfLineMapperDirection() {
495 case 0L:
return "PTRACE_ATTACH";
496 case 1L:
return "PTRACE_CONT";
497 case 2L:
return "PTRACE_DETACH";
498 case 3L:
return "PTRACE_GETREGS";
499 case 4L:
return "PTRACE_GETFPREGS";
500 case 5L:
return "PTRACE_KILL";
501 case 6L:
return "PTRACE_SETREGS";
502 case 7L:
return "PTRACE_SINGLESTEP";
503 case 8L:
return "PTRACE_TRACEME";
504 case 9L:
return "PTRACE_PEEKUSER";
512 s =
"(__ptrace_request)" + boost::lexical_cast<std::string>(i);
513 if (boost::starts_with(s, strip))
514 s = s.substr(strip.size());
519 static const int64_t values[] = {
531 static const std::vector<int64_t> retval(values, values + 10);
538 std::string stringify__ptrace_request(int64_t i,
const char *strip,
bool canonic) {
540 if (retval.empty()) {
541 retval =
"(__ptrace_request)" + boost::lexical_cast<std::string>(i);
543 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
544 retval = retval.substr(strlen(strip));
546 retval =
"__ptrace_request::" + retval;
551 const std::vector<int64_t>& stringify__ptrace_request() {
561 case 0L:
return "NOT_REACHABLE";
562 case 1L:
return "PROGRAM_ENTRY_POINT";
563 case 2L:
return "EXPORTED_FUNCTION";
564 case 4L:
return "SIGNAL_HANDLER";
565 case 128L:
return "ASSUMED";
566 case 256L:
return "EXPLICIT_MEM_CONSTANT";
567 case 512L:
return "EXPLICIT_INSN_CONSTANT";
568 case 1024L:
return "IMPLICIT_FUNC_CONSTANT";
569 case 65536L:
return "USER_DEFINED_0";
570 case 131072L:
return "USER_DEFINED_1";
571 case 262144L:
return "USER_DEFINED_2";
572 case 524288L:
return "USER_DEFINED_3";
573 case 1048576L:
return "USER_DEFINED_4";
574 case 2097152L:
return "USER_DEFINED_5";
575 case 4194304L:
return "USER_DEFINED_6";
576 case 8388608L:
return "USER_DEFINED_7";
577 case 16777216L:
return "USER_DEFINED_8";
578 case 33554432L:
return "USER_DEFINED_9";
579 case 67108864L:
return "USER_DEFINED_10";
580 case 134217728L:
return "USER_DEFINED_11";
581 case 268435456L:
return "USER_DEFINED_12";
582 case 536870912L:
return "USER_DEFINED_13";
583 case 1073741824L:
return "USER_DEFINED_14";
584 case 2147483648L:
return "USER_DEFINED_15";
589 std::string
Reason(int64_t i,
const std::string &strip) {
590 std::string s =
Reason(i);
592 s =
"(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
593 if (boost::starts_with(s, strip))
594 s = s.substr(strip.size());
599 static const int64_t values[] = {
625 static const std::vector<int64_t> retval(values, values + 24);
632 std::string stringifyBinaryAnalysisReachabilityReason(int64_t i,
const char *strip,
bool canonic) {
634 if (retval.empty()) {
635 retval =
"(Rose::BinaryAnalysis::Reachability::Reason)" + boost::lexical_cast<std::string>(i);
637 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
638 retval = retval.substr(strlen(strip));
640 retval =
"Rose::BinaryAnalysis::Reachability::Reason::" + retval;
645 const std::vector<int64_t>& stringifyBinaryAnalysisReachabilityReason() {
655 case 0L:
return "CARTESIAN_POINT";
656 case 1L:
return "ORDERED_LIST";
661 std::string
CValKind(int64_t i,
const std::string &strip) {
664 s =
"(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
665 if (boost::starts_with(s, strip))
666 s = s.substr(strip.size());
671 static const int64_t values[] = {
675 static const std::vector<int64_t> retval(values, values + 2);
682 std::string stringifyBinaryAnalysisFunctionSimilarityCValKind(int64_t i,
const char *strip,
bool canonic) {
684 if (retval.empty()) {
685 retval =
"(Rose::BinaryAnalysis::FunctionSimilarity::CValKind)" + boost::lexical_cast<std::string>(i);
687 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
688 retval = retval.substr(strlen(strip));
690 retval =
"Rose::BinaryAnalysis::FunctionSimilarity::CValKind::" + retval;
695 const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityCValKind() {
705 case 0L:
return "AVERAGE";
706 case 1L:
return "MEDIAN";
707 case 2L:
return "MAXIMUM";
712 std::string
Statistic(int64_t i,
const std::string &strip) {
715 s =
"(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
716 if (boost::starts_with(s, strip))
717 s = s.substr(strip.size());
722 static const int64_t values[] = {
727 static const std::vector<int64_t> retval(values, values + 3);
734 std::string stringifyBinaryAnalysisFunctionSimilarityStatistic(int64_t i,
const char *strip,
bool canonic) {
736 if (retval.empty()) {
737 retval =
"(Rose::BinaryAnalysis::FunctionSimilarity::Statistic)" + boost::lexical_cast<std::string>(i);
739 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
740 retval = retval.substr(strlen(strip));
742 retval =
"Rose::BinaryAnalysis::FunctionSimilarity::Statistic::" + retval;
747 const std::vector<int64_t>& stringifyBinaryAnalysisFunctionSimilarityStatistic() {
757 case 0L:
return "LM_NONE";
758 case 1L:
return "LM_LIBRARY";
759 case 2L:
return "LM_EXECUTABLE";
760 case 3L:
return "LM_ANY";
765 std::string
LinkMode(int64_t i,
const std::string &strip) {
768 s =
"(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
769 if (boost::starts_with(s, strip))
770 s = s.substr(strip.size());
775 static const int64_t values[] = {
781 static const std::vector<int64_t> retval(values, values + 4);
788 std::string stringifyBinaryAnalysisSmtSolverLinkMode(int64_t i,
const char *strip,
bool canonic) {
790 if (retval.empty()) {
791 retval =
"(Rose::BinaryAnalysis::SmtSolver::LinkMode)" + boost::lexical_cast<std::string>(i);
793 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
794 retval = retval.substr(strlen(strip));
796 retval =
"Rose::BinaryAnalysis::SmtSolver::LinkMode::" + retval;
801 const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverLinkMode() {
811 case 0L:
return "NO_TYPE";
812 case 1L:
return "BOOLEAN";
813 case 2L:
return "BIT_VECTOR";
814 case 3L:
return "MEM_STATE";
819 std::string
Type(int64_t i,
const std::string &strip) {
820 std::string s =
Type(i);
822 s =
"(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
823 if (boost::starts_with(s, strip))
824 s = s.substr(strip.size());
828 const std::vector<int64_t>&
Type() {
829 static const int64_t values[] = {
835 static const std::vector<int64_t> retval(values, values + 4);
842 std::string stringifyBinaryAnalysisSmtSolverType(int64_t i,
const char *strip,
bool canonic) {
844 if (retval.empty()) {
845 retval =
"(Rose::BinaryAnalysis::SmtSolver::Type)" + boost::lexical_cast<std::string>(i);
847 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
848 retval = retval.substr(strlen(strip));
850 retval =
"Rose::BinaryAnalysis::SmtSolver::Type::" + retval;
855 const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverType() {
865 case 0L:
return "SAT_NO";
866 case 1L:
return "SAT_YES";
867 case 2L:
return "SAT_UNKNOWN";
875 s =
"(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
876 if (boost::starts_with(s, strip))
877 s = s.substr(strip.size());
882 static const int64_t values[] = {
887 static const std::vector<int64_t> retval(values, values + 3);
894 std::string stringifyBinaryAnalysisSmtSolverSatisfiable(int64_t i,
const char *strip,
bool canonic) {
896 if (retval.empty()) {
897 retval =
"(Rose::BinaryAnalysis::SmtSolver::Satisfiable)" + boost::lexical_cast<std::string>(i);
899 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
900 retval = retval.substr(strlen(strip));
902 retval =
"Rose::BinaryAnalysis::SmtSolver::Satisfiable::" + retval;
907 const std::vector<int64_t>& stringifyBinaryAnalysisSmtSolverSatisfiable() {
914 namespace stringify {
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
namespace DataFlowSemantics {
namespace DataFlowEdge {
917 case 0L:
return "CLOBBER";
918 case 1L:
return "AUGMENT";
923 std::string
EdgeType(int64_t i,
const std::string &strip) {
926 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
927 if (boost::starts_with(s, strip))
928 s = s.substr(strip.size());
933 static const int64_t values[] = {
937 static const std::vector<int64_t> retval(values, values + 2);
944 std::string stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType(int64_t i,
const char *strip,
bool canonic) {
946 if (retval.empty()) {
947 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
949 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
950 retval = retval.substr(strlen(strip));
952 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::DataFlowSemantics::DataFlowEdge::EdgeType::" + retval;
957 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DataFlowSemanticsDataFlowEdgeEdgeType() {
967 case 0L:
return "IO_READ";
968 case 1L:
return "IO_WRITE";
969 case 2L:
return "IO_INIT";
970 case 3L:
return "IO_READ_BEFORE_WRITE";
971 case 4L:
return "IO_READ_AFTER_WRITE";
972 case 5L:
return "IO_READ_UNINITIALIZED";
980 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
981 if (boost::starts_with(s, strip))
982 s = s.substr(strip.size());
987 static const int64_t values[] = {
995 static const std::vector<int64_t> retval(values, values + 6);
1002 std::string stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty(int64_t i,
const char *strip,
bool canonic) {
1004 if (retval.empty()) {
1005 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty)" + boost::lexical_cast<std::string>(i);
1007 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1008 retval = retval.substr(strlen(strip));
1010 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::InputOutputProperty::" + retval;
1015 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2BaseSemanticsInputOutputProperty() {
1025 case 0L:
return "NO";
1026 case 1L:
return "YES";
1031 std::string
Flag(int64_t i,
const std::string &strip) {
1032 std::string s =
Flag(i);
1034 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
1035 if (boost::starts_with(s, strip))
1036 s = s.substr(strip.size());
1040 const std::vector<int64_t>&
Flag() {
1041 static const int64_t values[] = {
1045 static const std::vector<int64_t> retval(values, values + 2);
1052 std::string stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag(int64_t i,
const char *strip,
bool canonic) {
1054 if (retval.empty()) {
1055 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag)" + boost::lexical_cast<std::string>(i);
1057 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1058 retval = retval.substr(strlen(strip));
1060 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::UpdateCr::Flag::" + retval;
1065 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2UpdateCrFlag() {
1075 case 0L:
return "NO";
1076 case 1L:
return "YES";
1081 std::string
Flag(int64_t i,
const std::string &strip) {
1082 std::string s =
Flag(i);
1084 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
1085 if (boost::starts_with(s, strip))
1086 s = s.substr(strip.size());
1090 const std::vector<int64_t>&
Flag() {
1091 static const int64_t values[] = {
1095 static const std::vector<int64_t> retval(values, values + 2);
1102 std::string stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag(int64_t i,
const char *strip,
bool canonic) {
1104 if (retval.empty()) {
1105 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag)" + boost::lexical_cast<std::string>(i);
1107 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1108 retval = retval.substr(strlen(strip));
1110 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::SaveLink::Flag::" + retval;
1115 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SaveLinkFlag() {
1125 case 0L:
return "C_FALSE";
1126 case 1L:
return "C_TRUE";
1127 case 2L:
return "C_UNKNOWN";
1132 std::string
Carry(int64_t i,
const std::string &strip) {
1133 std::string s =
Carry(i);
1135 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
1136 if (boost::starts_with(s, strip))
1137 s = s.substr(strip.size());
1142 static const int64_t values[] = {
1147 static const std::vector<int64_t> retval(values, values + 3);
1154 std::string stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry(int64_t i,
const char *strip,
bool canonic) {
1156 if (retval.empty()) {
1157 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry)" + boost::lexical_cast<std::string>(i);
1159 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1160 retval = retval.substr(strlen(strip));
1162 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::IntervalSemantics::Carry::" + retval;
1167 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2IntervalSemanticsCarry() {
1174 namespace stringify {
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
namespace SymbolicSemantics {
namespace AllowSideEffects {
1177 case 0L:
return "NO";
1178 case 1L:
return "YES";
1183 std::string
Flag(int64_t i,
const std::string &strip) {
1184 std::string s =
Flag(i);
1186 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
1187 if (boost::starts_with(s, strip))
1188 s = s.substr(strip.size());
1192 const std::vector<int64_t>&
Flag() {
1193 static const int64_t values[] = {
1197 static const std::vector<int64_t> retval(values, values + 2);
1204 std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag(int64_t i,
const char *strip,
bool canonic) {
1206 if (retval.empty()) {
1207 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag)" + boost::lexical_cast<std::string>(i);
1209 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1210 retval = retval.substr(strlen(strip));
1212 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::AllowSideEffects::Flag::" + retval;
1217 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsAllowSideEffectsFlag() {
1227 case 0L:
return "TRACK_NO_WRITERS";
1228 case 1L:
return "TRACK_LATEST_WRITER";
1229 case 2L:
return "TRACK_ALL_WRITERS";
1237 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
1238 if (boost::starts_with(s, strip))
1239 s = s.substr(strip.size());
1244 static const int64_t values[] = {
1249 static const std::vector<int64_t> retval(values, values + 3);
1256 std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode(int64_t i,
const char *strip,
bool canonic) {
1258 if (retval.empty()) {
1259 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode)" + boost::lexical_cast<std::string>(i);
1261 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1262 retval = retval.substr(strlen(strip));
1264 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::WritersMode::" + retval;
1269 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsWritersMode() {
1279 case 0L:
return "TRACK_NO_DEFINERS";
1280 case 1L:
return "TRACK_LATEST_DEFINER";
1281 case 2L:
return "TRACK_ALL_DEFINERS";
1289 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
1290 if (boost::starts_with(s, strip))
1291 s = s.substr(strip.size());
1296 static const int64_t values[] = {
1301 static const std::vector<int64_t> retval(values, values + 3);
1308 std::string stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode(int64_t i,
const char *strip,
bool canonic) {
1310 if (retval.empty()) {
1311 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode)" + boost::lexical_cast<std::string>(i);
1313 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1314 retval = retval.substr(strlen(strip));
1316 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::SymbolicSemantics::DefinersMode::" + retval;
1321 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2SymbolicSemanticsDefinersMode() {
1331 case 0L:
return "READ_REGISTER";
1332 case 1L:
return "PEEK_REGISTER";
1340 s =
"(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
1341 if (boost::starts_with(s, strip))
1342 s = s.substr(strip.size());
1347 static const int64_t values[] = {
1351 static const std::vector<int64_t> retval(values, values + 2);
1358 std::string stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode(int64_t i,
const char *strip,
bool canonic) {
1360 if (retval.empty()) {
1361 retval =
"(Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode)" + boost::lexical_cast<std::string>(i);
1363 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1364 retval = retval.substr(strlen(strip));
1366 retval =
"Rose::BinaryAnalysis::InstructionSemantics2::DispatcherX86::AccessMode::" + retval;
1371 const std::vector<int64_t>& stringifyBinaryAnalysisInstructionSemantics2DispatcherX86AccessMode() {
1381 case 0L:
return "BOTTOM";
1382 case 1L:
return "NOT_TAINTED";
1383 case 2L:
return "TAINTED";
1384 case 3L:
return "TOP";
1392 s =
"(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
1393 if (boost::starts_with(s, strip))
1394 s = s.substr(strip.size());
1399 static const int64_t values[] = {
1405 static const std::vector<int64_t> retval(values, values + 4);
1412 std::string stringifyBinaryAnalysisTaintedFlowTaintedness(int64_t i,
const char *strip,
bool canonic) {
1414 if (retval.empty()) {
1415 retval =
"(Rose::BinaryAnalysis::TaintedFlow::Taintedness)" + boost::lexical_cast<std::string>(i);
1417 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1418 retval = retval.substr(strlen(strip));
1420 retval =
"Rose::BinaryAnalysis::TaintedFlow::Taintedness::" + retval;
1425 const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowTaintedness() {
1435 case 0L:
return "UNDER_APPROXIMATE";
1436 case 1L:
return "OVER_APPROXIMATE";
1444 s =
"(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
1445 if (boost::starts_with(s, strip))
1446 s = s.substr(strip.size());
1451 static const int64_t values[] = {
1455 static const std::vector<int64_t> retval(values, values + 2);
1462 std::string stringifyBinaryAnalysisTaintedFlowApproximation(int64_t i,
const char *strip,
bool canonic) {
1464 if (retval.empty()) {
1465 retval =
"(Rose::BinaryAnalysis::TaintedFlow::Approximation)" + boost::lexical_cast<std::string>(i);
1467 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1468 retval = retval.substr(strlen(strip));
1470 retval =
"Rose::BinaryAnalysis::TaintedFlow::Approximation::" + retval;
1475 const std::vector<int64_t>& stringifyBinaryAnalysisTaintedFlowApproximation() {
1485 case 0L:
return "FULL";
1486 case 1L:
return "ABBREVIATED";
1491 std::string
Flag(int64_t i,
const std::string &strip) {
1492 std::string s =
Flag(i);
1494 s =
"(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
1495 if (boost::starts_with(s, strip))
1496 s = s.substr(strip.size());
1500 const std::vector<int64_t>&
Flag() {
1501 static const int64_t values[] = {
1505 static const std::vector<int64_t> retval(values, values + 2);
1512 std::string stringifyBinaryAnalysisSymbolicExprTypeStyleFlag(int64_t i,
const char *strip,
bool canonic) {
1514 if (retval.empty()) {
1515 retval =
"(Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag)" + boost::lexical_cast<std::string>(i);
1517 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1518 retval = retval.substr(strlen(strip));
1520 retval =
"Rose::BinaryAnalysis::SymbolicExpr::TypeStyle::Flag::" + retval;
1525 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeStyleFlag() {
1535 case 0L:
return "OP_ADD";
1536 case 1L:
return "OP_AND";
1537 case 2L:
return "OP_ASR";
1538 case 3L:
return "OP_CONCAT";
1539 case 4L:
return "OP_EQ";
1540 case 5L:
return "OP_EXTRACT";
1541 case 6L:
return "OP_INVERT";
1542 case 7L:
return "OP_ITE";
1543 case 8L:
return "OP_LET";
1544 case 9L:
return "OP_LSSB";
1545 case 10L:
return "OP_MSSB";
1546 case 11L:
return "OP_NE";
1547 case 12L:
return "OP_NEGATE";
1548 case 13L:
return "OP_NOOP";
1549 case 14L:
return "OP_OR";
1550 case 15L:
return "OP_READ";
1551 case 16L:
return "OP_ROL";
1552 case 17L:
return "OP_ROR";
1553 case 18L:
return "OP_SDIV";
1554 case 19L:
return "OP_SET";
1555 case 20L:
return "OP_SEXTEND";
1556 case 21L:
return "OP_SGE";
1557 case 22L:
return "OP_SGT";
1558 case 23L:
return "OP_SHL0";
1559 case 24L:
return "OP_SHL1";
1560 case 25L:
return "OP_SHR0";
1561 case 26L:
return "OP_SHR1";
1562 case 27L:
return "OP_SLE";
1563 case 28L:
return "OP_SLT";
1564 case 29L:
return "OP_SMOD";
1565 case 30L:
return "OP_SMUL";
1566 case 31L:
return "OP_UDIV";
1567 case 32L:
return "OP_UEXTEND";
1568 case 33L:
return "OP_UGE";
1569 case 34L:
return "OP_UGT";
1570 case 35L:
return "OP_ULE";
1571 case 36L:
return "OP_ULT";
1572 case 37L:
return "OP_UMOD";
1573 case 38L:
return "OP_UMUL";
1574 case 39L:
return "OP_WRITE";
1575 case 40L:
return "OP_XOR";
1576 case 41L:
return "OP_ZEROP";
1577 case 42L:
return "OP_FP_ABS";
1578 case 43L:
return "OP_FP_NEGATE";
1579 case 44L:
return "OP_FP_ADD";
1580 case 45L:
return "OP_FP_MUL";
1581 case 46L:
return "OP_FP_DIV";
1582 case 47L:
return "OP_FP_MULADD";
1583 case 48L:
return "OP_FP_SQRT";
1584 case 49L:
return "OP_FP_MOD";
1585 case 50L:
return "OP_FP_ROUND";
1586 case 51L:
return "OP_FP_MIN";
1587 case 52L:
return "OP_FP_MAX";
1588 case 53L:
return "OP_FP_LE";
1589 case 54L:
return "OP_FP_LT";
1590 case 55L:
return "OP_FP_GE";
1591 case 56L:
return "OP_FP_GT";
1592 case 57L:
return "OP_FP_EQ";
1593 case 58L:
return "OP_FP_ISNORM";
1594 case 59L:
return "OP_FP_ISSUBNORM";
1595 case 60L:
return "OP_FP_ISZERO";
1596 case 61L:
return "OP_FP_ISINFINITE";
1597 case 62L:
return "OP_FP_ISNAN";
1598 case 63L:
return "OP_FP_ISNEG";
1599 case 64L:
return "OP_FP_ISPOS";
1600 case 65L:
return "OP_CONVERT";
1601 case 66L:
return "OP_REINTERPRET";
1602 case 67L:
return "OP_NONE";
1607 std::string
Operator(int64_t i,
const std::string &strip) {
1610 s =
"(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
1611 if (boost::starts_with(s, strip))
1612 s = s.substr(strip.size());
1617 static const int64_t values[] = {
1687 static const std::vector<int64_t> retval(values, values + 68);
1694 std::string stringifyBinaryAnalysisSymbolicExprOperator(int64_t i,
const char *strip,
bool canonic) {
1696 if (retval.empty()) {
1697 retval =
"(Rose::BinaryAnalysis::SymbolicExpr::Operator)" + boost::lexical_cast<std::string>(i);
1699 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1700 retval = retval.substr(strlen(strip));
1702 retval =
"Rose::BinaryAnalysis::SymbolicExpr::Operator::" + retval;
1707 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprOperator() {
1717 case 0L:
return "CMT_SILENT";
1718 case 1L:
return "CMT_AFTER";
1719 case 2L:
return "CMT_INSTEAD";
1727 s =
"(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
1728 if (boost::starts_with(s, strip))
1729 s = s.substr(strip.size());
1734 static const int64_t values[] = {
1739 static const std::vector<int64_t> retval(values, values + 3);
1746 std::string stringifyBinaryAnalysisSymbolicExprFormatterShowComments(int64_t i,
const char *strip,
bool canonic) {
1748 if (retval.empty()) {
1749 retval =
"(Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments)" + boost::lexical_cast<std::string>(i);
1751 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1752 retval = retval.substr(strlen(strip));
1754 retval =
"Rose::BinaryAnalysis::SymbolicExpr::Formatter::ShowComments::" + retval;
1759 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprFormatterShowComments() {
1769 case 0L:
return "CONTINUE";
1770 case 1L:
return "TRUNCATE";
1771 case 2L:
return "TERMINATE";
1779 s =
"(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
1780 if (boost::starts_with(s, strip))
1781 s = s.substr(strip.size());
1786 static const int64_t values[] = {
1791 static const std::vector<int64_t> retval(values, values + 3);
1798 std::string stringifyBinaryAnalysisSymbolicExprVisitAction(int64_t i,
const char *strip,
bool canonic) {
1800 if (retval.empty()) {
1801 retval =
"(Rose::BinaryAnalysis::SymbolicExpr::VisitAction)" + boost::lexical_cast<std::string>(i);
1803 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1804 retval = retval.substr(strlen(strip));
1806 retval =
"Rose::BinaryAnalysis::SymbolicExpr::VisitAction::" + retval;
1811 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprVisitAction() {
1821 case 0L:
return "INTEGER";
1822 case 1L:
return "FP";
1823 case 2L:
return "MEMORY";
1824 case 3L:
return "INVALID";
1829 std::string
TypeClass(int64_t i,
const std::string &strip) {
1832 s =
"(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
1833 if (boost::starts_with(s, strip))
1834 s = s.substr(strip.size());
1839 static const int64_t values[] = {
1845 static const std::vector<int64_t> retval(values, values + 4);
1852 std::string stringifyBinaryAnalysisSymbolicExprTypeTypeClass(int64_t i,
const char *strip,
bool canonic) {
1854 if (retval.empty()) {
1855 retval =
"(Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass)" + boost::lexical_cast<std::string>(i);
1857 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1858 retval = retval.substr(strlen(strip));
1860 retval =
"Rose::BinaryAnalysis::SymbolicExpr::Type::TypeClass::" + retval;
1865 const std::vector<int64_t>& stringifyBinaryAnalysisSymbolicExprTypeTypeClass() {
1875 case 0L:
return "NO";
1876 case 1L:
return "YES";
1881 std::string
Boolean(int64_t i,
const std::string &strip) {
1884 s =
"(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
1885 if (boost::starts_with(s, strip))
1886 s = s.substr(strip.size());
1891 static const int64_t values[] = {
1895 static const std::vector<int64_t> retval(values, values + 2);
1902 std::string stringifyBinaryAnalysisCommitBoolean(int64_t i,
const char *strip,
bool canonic) {
1904 if (retval.empty()) {
1905 retval =
"(Rose::BinaryAnalysis::Commit::Boolean)" + boost::lexical_cast<std::string>(i);
1907 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1908 retval = retval.substr(strlen(strip));
1910 retval =
"Rose::BinaryAnalysis::Commit::Boolean::" + retval;
1915 const std::vector<int64_t>& stringifyBinaryAnalysisCommitBoolean() {
1925 case 1L:
return "AGGREGATE_PREDECESSORS";
1926 case 2L:
return "AGGREGATE_SUCCESSORS";
1934 s =
"(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
1935 if (boost::starts_with(s, strip))
1936 s = s.substr(strip.size());
1941 static const int64_t values[] = {
1945 static const std::vector<int64_t> retval(values, values + 2);
1952 std::string stringifyBinaryAnalysisCodeInserterAggregationDirection(int64_t i,
const char *strip,
bool canonic) {
1954 if (retval.empty()) {
1955 retval =
"(Rose::BinaryAnalysis::CodeInserter::AggregationDirection)" + boost::lexical_cast<std::string>(i);
1957 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
1958 retval = retval.substr(strlen(strip));
1960 retval =
"Rose::BinaryAnalysis::CodeInserter::AggregationDirection::" + retval;
1965 const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterAggregationDirection() {
1975 case 0L:
return "PAD_NOP_BACK";
1976 case 1L:
return "PAD_NOP_FRONT";
1977 case 2L:
return "PAD_RANDOM_BACK";
1985 s =
"(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
1986 if (boost::starts_with(s, strip))
1987 s = s.substr(strip.size());
1992 static const int64_t values[] = {
1997 static const std::vector<int64_t> retval(values, values + 3);
2004 std::string stringifyBinaryAnalysisCodeInserterNopPadding(int64_t i,
const char *strip,
bool canonic) {
2006 if (retval.empty()) {
2007 retval =
"(Rose::BinaryAnalysis::CodeInserter::NopPadding)" + boost::lexical_cast<std::string>(i);
2009 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2010 retval = retval.substr(strlen(strip));
2012 retval =
"Rose::BinaryAnalysis::CodeInserter::NopPadding::" + retval;
2017 const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterNopPadding() {
2027 case 0L:
return "RELOC_INDEX_ABS_LE32";
2028 case 1L:
return "RELOC_INDEX_ABS_LE32HI";
2029 case 2L:
return "RELOC_INDEX_ABS_BE32";
2030 case 3L:
return "RELOC_ADDR_REL_LE32";
2031 case 4L:
return "RELOC_ADDR_REL_BE32";
2032 case 5L:
return "RELOC_INSN_ABS_LE32";
2033 case 6L:
return "RELOC_INSN_REL_LE32";
2034 case 7L:
return "RELOC_INSN_REL_BE32";
2039 std::string
RelocType(int64_t i,
const std::string &strip) {
2042 s =
"(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
2043 if (boost::starts_with(s, strip))
2044 s = s.substr(strip.size());
2049 static const int64_t values[] = {
2059 static const std::vector<int64_t> retval(values, values + 8);
2066 std::string stringifyBinaryAnalysisCodeInserterRelocType(int64_t i,
const char *strip,
bool canonic) {
2068 if (retval.empty()) {
2069 retval =
"(Rose::BinaryAnalysis::CodeInserter::RelocType)" + boost::lexical_cast<std::string>(i);
2071 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2072 retval = retval.substr(strlen(strip));
2074 retval =
"Rose::BinaryAnalysis::CodeInserter::RelocType::" + retval;
2079 const std::vector<int64_t>& stringifyBinaryAnalysisCodeInserterRelocType() {
2089 case 0L:
return "LEFT_TO_RIGHT";
2090 case 1L:
return "RIGHT_TO_LEFT";
2091 case 2L:
return "ORDER_UNSPECIFIED";
2099 s =
"(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
2100 if (boost::starts_with(s, strip))
2101 s = s.substr(strip.size());
2106 static const int64_t values[] = {
2111 static const std::vector<int64_t> retval(values, values + 3);
2118 std::string stringifyBinaryAnalysisCallingConventionStackParameterOrder(int64_t i,
const char *strip,
bool canonic) {
2120 if (retval.empty()) {
2121 retval =
"(Rose::BinaryAnalysis::CallingConvention::StackParameterOrder)" + boost::lexical_cast<std::string>(i);
2123 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2124 retval = retval.substr(strlen(strip));
2126 retval =
"Rose::BinaryAnalysis::CallingConvention::StackParameterOrder::" + retval;
2131 const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackParameterOrder() {
2141 case 0L:
return "GROWS_UP";
2142 case 1L:
return "GROWS_DOWN";
2150 s =
"(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
2151 if (boost::starts_with(s, strip))
2152 s = s.substr(strip.size());
2157 static const int64_t values[] = {
2161 static const std::vector<int64_t> retval(values, values + 2);
2168 std::string stringifyBinaryAnalysisCallingConventionStackDirection(int64_t i,
const char *strip,
bool canonic) {
2170 if (retval.empty()) {
2171 retval =
"(Rose::BinaryAnalysis::CallingConvention::StackDirection)" + boost::lexical_cast<std::string>(i);
2173 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2174 retval = retval.substr(strlen(strip));
2176 retval =
"Rose::BinaryAnalysis::CallingConvention::StackDirection::" + retval;
2181 const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackDirection() {
2191 case 0L:
return "CLEANUP_BY_CALLER";
2192 case 1L:
return "CLEANUP_BY_CALLEE";
2193 case 2L:
return "CLEANUP_UNSPECIFIED";
2201 s =
"(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
2202 if (boost::starts_with(s, strip))
2203 s = s.substr(strip.size());
2208 static const int64_t values[] = {
2213 static const std::vector<int64_t> retval(values, values + 3);
2220 std::string stringifyBinaryAnalysisCallingConventionStackCleanup(int64_t i,
const char *strip,
bool canonic) {
2222 if (retval.empty()) {
2223 retval =
"(Rose::BinaryAnalysis::CallingConvention::StackCleanup)" + boost::lexical_cast<std::string>(i);
2225 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2226 retval = retval.substr(strlen(strip));
2228 retval =
"Rose::BinaryAnalysis::CallingConvention::StackCleanup::" + retval;
2233 const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionStackCleanup() {
2243 case 0L:
return "NO_LOCATION";
2244 case 1L:
return "REGISTER";
2245 case 2L:
return "STACK";
2246 case 3L:
return "ABSOLUTE";
2251 std::string
Type(int64_t i,
const std::string &strip) {
2252 std::string s =
Type(i);
2254 s =
"(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
2255 if (boost::starts_with(s, strip))
2256 s = s.substr(strip.size());
2260 const std::vector<int64_t>&
Type() {
2261 static const int64_t values[] = {
2267 static const std::vector<int64_t> retval(values, values + 4);
2274 std::string stringifyBinaryAnalysisCallingConventionParameterLocationType(int64_t i,
const char *strip,
bool canonic) {
2276 if (retval.empty()) {
2277 retval =
"(Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type)" + boost::lexical_cast<std::string>(i);
2279 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2280 retval = retval.substr(strlen(strip));
2282 retval =
"Rose::BinaryAnalysis::CallingConvention::ParameterLocation::Type::" + retval;
2287 const std::vector<int64_t>& stringifyBinaryAnalysisCallingConventionParameterLocationType() {
2297 case 0L:
return "SEARCH_SINGLE_DFS";
2298 case 1L:
return "SEARCH_SINGLE_BFS";
2299 case 2L:
return "SEARCH_MULTI";
2307 s =
"(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
2308 if (boost::starts_with(s, strip))
2309 s = s.substr(strip.size());
2314 static const int64_t values[] = {
2319 static const std::vector<int64_t> retval(values, values + 3);
2326 std::string stringifyBinaryAnalysisFeasiblePathSearchMode(int64_t i,
const char *strip,
bool canonic) {
2328 if (retval.empty()) {
2329 retval =
"(Rose::BinaryAnalysis::FeasiblePath::SearchMode)" + boost::lexical_cast<std::string>(i);
2331 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2332 retval = retval.substr(strlen(strip));
2334 retval =
"Rose::BinaryAnalysis::FeasiblePath::SearchMode::" + retval;
2339 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSearchMode() {
2349 case 0L:
return "LIST_BASED_MEMORY";
2350 case 1L:
return "MAP_BASED_MEMORY";
2358 s =
"(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
2359 if (boost::starts_with(s, strip))
2360 s = s.substr(strip.size());
2365 static const int64_t values[] = {
2369 static const std::vector<int64_t> retval(values, values + 2);
2376 std::string stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm(int64_t i,
const char *strip,
bool canonic) {
2378 if (retval.empty()) {
2379 retval =
"(Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm)" + boost::lexical_cast<std::string>(i);
2381 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2382 retval = retval.substr(strlen(strip));
2384 retval =
"Rose::BinaryAnalysis::FeasiblePath::SemanticMemoryParadigm::" + retval;
2389 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathSemanticMemoryParadigm() {
2399 case 0L:
return "VISIT_NATURAL";
2400 case 1L:
return "VISIT_REVERSE";
2401 case 2L:
return "VISIT_RANDOM";
2409 s =
"(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
2410 if (boost::starts_with(s, strip))
2411 s = s.substr(strip.size());
2416 static const int64_t values[] = {
2421 static const std::vector<int64_t> retval(values, values + 3);
2428 std::string stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder(int64_t i,
const char *strip,
bool canonic) {
2430 if (retval.empty()) {
2431 retval =
"(Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder)" + boost::lexical_cast<std::string>(i);
2433 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2434 retval = retval.substr(strlen(strip));
2436 retval =
"Rose::BinaryAnalysis::FeasiblePath::EdgeVisitOrder::" + retval;
2441 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathEdgeVisitOrder() {
2451 case 0L:
return "READ";
2452 case 1L:
return "WRITE";
2457 std::string
IoMode(int64_t i,
const std::string &strip) {
2458 std::string s =
IoMode(i);
2460 s =
"(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
2461 if (boost::starts_with(s, strip))
2462 s = s.substr(strip.size());
2467 static const int64_t values[] = {
2471 static const std::vector<int64_t> retval(values, values + 2);
2478 std::string stringifyBinaryAnalysisFeasiblePathIoMode(int64_t i,
const char *strip,
bool canonic) {
2480 if (retval.empty()) {
2481 retval =
"(Rose::BinaryAnalysis::FeasiblePath::IoMode)" + boost::lexical_cast<std::string>(i);
2483 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2484 retval = retval.substr(strlen(strip));
2486 retval =
"Rose::BinaryAnalysis::FeasiblePath::IoMode::" + retval;
2491 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathIoMode() {
2501 case 0L:
return "MAY";
2502 case 1L:
return "MUST";
2507 std::string
MayOrMust(int64_t i,
const std::string &strip) {
2510 s =
"(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
2511 if (boost::starts_with(s, strip))
2512 s = s.substr(strip.size());
2517 static const int64_t values[] = {
2521 static const std::vector<int64_t> retval(values, values + 2);
2528 std::string stringifyBinaryAnalysisFeasiblePathMayOrMust(int64_t i,
const char *strip,
bool canonic) {
2530 if (retval.empty()) {
2531 retval =
"(Rose::BinaryAnalysis::FeasiblePath::MayOrMust)" + boost::lexical_cast<std::string>(i);
2533 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2534 retval = retval.substr(strlen(strip));
2536 retval =
"Rose::BinaryAnalysis::FeasiblePath::MayOrMust::" + retval;
2541 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathMayOrMust() {
2551 case 0L:
return "BREAK";
2552 case 1L:
return "CONTINUE";
2557 std::string
Action(int64_t i,
const std::string &strip) {
2558 std::string s =
Action(i);
2560 s =
"(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
2561 if (boost::starts_with(s, strip))
2562 s = s.substr(strip.size());
2567 static const int64_t values[] = {
2571 static const std::vector<int64_t> retval(values, values + 2);
2578 std::string stringifyBinaryAnalysisFeasiblePathPathProcessorAction(int64_t i,
const char *strip,
bool canonic) {
2580 if (retval.empty()) {
2581 retval =
"(Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action)" + boost::lexical_cast<std::string>(i);
2583 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2584 retval = retval.substr(strlen(strip));
2586 retval =
"Rose::BinaryAnalysis::FeasiblePath::PathProcessor::Action::" + retval;
2591 const std::vector<int64_t>& stringifyBinaryAnalysisFeasiblePathPathProcessorAction() {
2601 case 0L:
return "FAST";
2602 case 1L:
return "SLOW";
2603 case 2L:
return "NONE";
2608 std::string
Mechanism(int64_t i,
const std::string &strip) {
2611 s =
"(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
2612 if (boost::starts_with(s, strip))
2613 s = s.substr(strip.size());
2618 static const int64_t values[] = {
2623 static const std::vector<int64_t> retval(values, values + 3);
2630 std::string stringifyBinaryAnalysisMagicNumberMechanism(int64_t i,
const char *strip,
bool canonic) {
2632 if (retval.empty()) {
2633 retval =
"(Rose::BinaryAnalysis::MagicNumber::Mechanism)" + boost::lexical_cast<std::string>(i);
2635 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2636 retval = retval.substr(strlen(strip));
2638 retval =
"Rose::BinaryAnalysis::MagicNumber::Mechanism::" + retval;
2643 const std::vector<int64_t>& stringifyBinaryAnalysisMagicNumberMechanism() {
2653 case 0L:
return "PATCH_REGISTER";
2654 case 1L:
return "PATCH_NONE";
2659 std::string
Type(int64_t i,
const std::string &strip) {
2660 std::string s =
Type(i);
2662 s =
"(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
2663 if (boost::starts_with(s, strip))
2664 s = s.substr(strip.size());
2668 const std::vector<int64_t>&
Type() {
2669 static const int64_t values[] = {
2673 static const std::vector<int64_t> retval(values, values + 2);
2680 std::string stringifyBinaryAnalysisHotPatchRecordType(int64_t i,
const char *strip,
bool canonic) {
2682 if (retval.empty()) {
2683 retval =
"(Rose::BinaryAnalysis::HotPatch::Record::Type)" + boost::lexical_cast<std::string>(i);
2685 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2686 retval = retval.substr(strlen(strip));
2688 retval =
"Rose::BinaryAnalysis::HotPatch::Record::Type::" + retval;
2693 const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordType() {
2703 case 0L:
return "MATCH_CONTINUE";
2704 case 1L:
return "MATCH_BREAK";
2709 std::string
Behavior(int64_t i,
const std::string &strip) {
2712 s =
"(Rose::BinaryAnalysis::HotPatch::Record::Behavior)" + boost::lexical_cast<std::string>(i);
2713 if (boost::starts_with(s, strip))
2714 s = s.substr(strip.size());
2719 static const int64_t values[] = {
2723 static const std::vector<int64_t> retval(values, values + 2);
2730 std::string stringifyBinaryAnalysisHotPatchRecordBehavior(int64_t i,
const char *strip,
bool canonic) {
2732 if (retval.empty()) {
2733 retval =
"(Rose::BinaryAnalysis::HotPatch::Record::Behavior)" + boost::lexical_cast<std::string>(i);
2735 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2736 retval = retval.substr(strlen(strip));
2738 retval =
"Rose::BinaryAnalysis::HotPatch::Record::Behavior::" + retval;
2743 const std::vector<int64_t>& stringifyBinaryAnalysisHotPatchRecordBehavior() {
2753 case -4L:
return "ERROR_STATE";
2754 case -3L:
return "INITIAL_STATE";
2755 case -2L:
return "COMPLETED_STATE";
2756 case -1L:
return "FINAL_STATE";
2757 case 0L:
return "USER_DEFINED_0";
2758 case 1L:
return "USER_DEFINED_1";
2759 case 2L:
return "USER_DEFINED_2";
2760 case 128L:
return "USER_DEFINED_MAX";
2765 std::string
State(int64_t i,
const std::string &strip) {
2766 std::string s =
State(i);
2768 s =
"(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
2769 if (boost::starts_with(s, strip))
2770 s = s.substr(strip.size());
2775 static const int64_t values[] = {
2785 static const std::vector<int64_t> retval(values, values + 8);
2792 std::string stringifyBinaryAnalysisStringsState(int64_t i,
const char *strip,
bool canonic) {
2794 if (retval.empty()) {
2795 retval =
"(Rose::BinaryAnalysis::Strings::State)" + boost::lexical_cast<std::string>(i);
2797 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2798 retval = retval.substr(strlen(strip));
2800 retval =
"Rose::BinaryAnalysis::Strings::State::" + retval;
2805 const std::vector<int64_t>& stringifyBinaryAnalysisStringsState() {
2815 case 0L:
return "KILL";
2816 case 1L:
return "DETACH";
2817 case 2L:
return "CONTINUE";
2818 case 3L:
return "NOTHING";
2826 s =
"(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
2827 if (boost::starts_with(s, strip))
2828 s = s.substr(strip.size());
2833 static const int64_t values[] = {
2839 static const std::vector<int64_t> retval(values, values + 4);
2846 std::string stringifyBinaryAnalysisDebuggerDetachMode(int64_t i,
const char *strip,
bool canonic) {
2848 if (retval.empty()) {
2849 retval =
"(Rose::BinaryAnalysis::Debugger::DetachMode)" + boost::lexical_cast<std::string>(i);
2851 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2852 retval = retval.substr(strlen(strip));
2854 retval =
"Rose::BinaryAnalysis::Debugger::DetachMode::" + retval;
2859 const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerDetachMode() {
2869 case 1L:
return "ATTACH";
2870 case 2L:
return "REDIRECT_INPUT";
2871 case 4L:
return "REDIRECT_OUTPUT";
2872 case 8L:
return "REDIRECT_ERROR";
2873 case 16L:
return "CLOSE_FILES";
2874 case 19L:
return "DEFAULT_FLAGS";
2879 std::string
Flag(int64_t i,
const std::string &strip) {
2880 std::string s =
Flag(i);
2882 s =
"(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
2883 if (boost::starts_with(s, strip))
2884 s = s.substr(strip.size());
2888 const std::vector<int64_t>&
Flag() {
2889 static const int64_t values[] = {
2897 static const std::vector<int64_t> retval(values, values + 6);
2904 std::string stringifyBinaryAnalysisDebuggerFlag(int64_t i,
const char *strip,
bool canonic) {
2906 if (retval.empty()) {
2907 retval =
"(Rose::BinaryAnalysis::Debugger::Flag)" + boost::lexical_cast<std::string>(i);
2909 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2910 retval = retval.substr(strlen(strip));
2912 retval =
"Rose::BinaryAnalysis::Debugger::Flag::" + retval;
2917 const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFlag() {
2927 case 0L:
return "REGPAGE_NONE";
2928 case 1L:
return "REGPAGE_REGS";
2929 case 2L:
return "REGPAGE_FPREGS";
2937 s =
"(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
2938 if (boost::starts_with(s, strip))
2939 s = s.substr(strip.size());
2944 static const int64_t values[] = {
2949 static const std::vector<int64_t> retval(values, values + 3);
2956 std::string stringifyBinaryAnalysisDebuggerRegPageStatus(int64_t i,
const char *strip,
bool canonic) {
2958 if (retval.empty()) {
2959 retval =
"(Rose::BinaryAnalysis::Debugger::RegPageStatus)" + boost::lexical_cast<std::string>(i);
2961 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
2962 retval = retval.substr(strlen(strip));
2964 retval =
"Rose::BinaryAnalysis::Debugger::RegPageStatus::" + retval;
2969 const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerRegPageStatus() {
2979 case 1L:
return "REJECT";
2980 case 2L:
return "STOP";
2988 s =
"(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
2989 if (boost::starts_with(s, strip))
2990 s = s.substr(strip.size());
2995 static const int64_t values[] = {
2999 static const std::vector<int64_t> retval(values, values + 2);
3006 std::string stringifyBinaryAnalysisDebuggerFilterActionFlags(int64_t i,
const char *strip,
bool canonic) {
3008 if (retval.empty()) {
3009 retval =
"(Rose::BinaryAnalysis::Debugger::FilterActionFlags)" + boost::lexical_cast<std::string>(i);
3011 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3012 retval = retval.substr(strlen(strip));
3014 retval =
"Rose::BinaryAnalysis::Debugger::FilterActionFlags::" + retval;
3019 const std::vector<int64_t>& stringifyBinaryAnalysisDebuggerFilterActionFlags() {
3029 case 0L:
return "PHI_FUNCTION";
3030 case 1L:
return "ORIGINAL_DEF";
3031 case 2L:
return "EXPANDED_DEF";
3032 case 3L:
return "EXTERNAL_DEF";
3037 std::string
Type(int64_t i,
const std::string &strip) {
3038 std::string s =
Type(i);
3040 s =
"(ssa_unfiltered_cfg::ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
3041 if (boost::starts_with(s, strip))
3042 s = s.substr(strip.size());
3046 const std::vector<int64_t>&
Type() {
3047 static const int64_t values[] = {
3053 static const std::vector<int64_t> retval(values, values + 4);
3060 std::string stringify_ssa_unfiltered_cfgReachingDefType(int64_t i,
const char *strip,
bool canonic) {
3062 if (retval.empty()) {
3063 retval =
"(ssa_unfiltered_cfg::ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
3065 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3066 retval = retval.substr(strlen(strip));
3068 retval =
"ssa_unfiltered_cfg::ReachingDef::Type::" + retval;
3073 const std::vector<int64_t>& stringify_ssa_unfiltered_cfgReachingDefType() {
3083 case 0L:
return "uninitialized";
3084 case 1L:
return "bottom";
3085 case 2L:
return "constrKnown";
3086 case 3L:
return "top";
3091 std::string
levels(int64_t i,
const std::string &strip) {
3092 std::string s =
levels(i);
3094 s =
"(ConstrGraph::levels)" + boost::lexical_cast<std::string>(i);
3095 if (boost::starts_with(s, strip))
3096 s = s.substr(strip.size());
3101 static const int64_t values[] = {
3107 static const std::vector<int64_t> retval(values, values + 4);
3114 std::string stringifyConstrGraph_levels(int64_t i,
const char *strip,
bool canonic) {
3116 if (retval.empty()) {
3117 retval =
"(ConstrGraph::levels)" + boost::lexical_cast<std::string>(i);
3119 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3120 retval = retval.substr(strlen(strip));
3122 retval =
"ConstrGraph::levels::" + retval;
3127 const std::vector<int64_t>& stringifyConstrGraph_levels() {
3137 case 0L:
return "fw";
3138 case 1L:
return "bw";
3143 std::string
direction(int64_t i,
const std::string &strip) {
3146 s =
"(CGFunction::iterator::direction)" + boost::lexical_cast<std::string>(i);
3147 if (boost::starts_with(s, strip))
3148 s = s.substr(strip.size());
3153 static const int64_t values[] = {
3157 static const std::vector<int64_t> retval(values, values + 2);
3164 std::string stringifyCGFunction_iterator_direction(int64_t i,
const char *strip,
bool canonic) {
3166 if (retval.empty()) {
3167 retval =
"(CGFunction::iterator::direction)" + boost::lexical_cast<std::string>(i);
3169 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3170 retval = retval.substr(strlen(strip));
3172 retval =
"CGFunction::iterator::direction::" + retval;
3177 const std::vector<int64_t>& stringifyCGFunction_iterator_direction() {
3187 case 0L:
return "VERTEX_BOTTOM";
3188 case 1L:
return "VERTEX_UNTAINTED";
3189 case 2L:
return "VERTEX_TAINTED";
3194 std::string
Vertex(int64_t i,
const std::string &strip) {
3195 std::string s =
Vertex(i);
3197 s =
"(TaintLattice::Vertex)" + boost::lexical_cast<std::string>(i);
3198 if (boost::starts_with(s, strip))
3199 s = s.substr(strip.size());
3204 static const int64_t values[] = {
3209 static const std::vector<int64_t> retval(values, values + 3);
3216 std::string stringifyTaintLatticeVertex(int64_t i,
const char *strip,
bool canonic) {
3218 if (retval.empty()) {
3219 retval =
"(TaintLattice::Vertex)" + boost::lexical_cast<std::string>(i);
3221 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3222 retval = retval.substr(strlen(strip));
3224 retval =
"TaintLattice::Vertex::" + retval;
3229 const std::vector<int64_t>& stringifyTaintLatticeVertex() {
3236 namespace stringify {
namespace Rose {
namespace EditDistance {
namespace TreeEditDistance {
3239 case 0L:
return "INSERT";
3240 case 1L:
return "DELETE";
3241 case 2L:
return "SUBSTITUTE";
3246 std::string
EditType(int64_t i,
const std::string &strip) {
3249 s =
"(Rose::EditDistance::TreeEditDistance::EditType)" + boost::lexical_cast<std::string>(i);
3250 if (boost::starts_with(s, strip))
3251 s = s.substr(strip.size());
3256 static const int64_t values[] = {
3261 static const std::vector<int64_t> retval(values, values + 3);
3268 std::string stringifyEditDistanceTreeEditDistanceEditType(int64_t i,
const char *strip,
bool canonic) {
3270 if (retval.empty()) {
3271 retval =
"(Rose::EditDistance::TreeEditDistance::EditType)" + boost::lexical_cast<std::string>(i);
3273 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3274 retval = retval.substr(strlen(strip));
3276 retval =
"Rose::EditDistance::TreeEditDistance::EditType::" + retval;
3281 const std::vector<int64_t>& stringifyEditDistanceTreeEditDistanceEditType() {
3291 case 0L:
return "TRUE_EDGE";
3292 case 1L:
return "FALLTHROUGH_EDGE";
3293 case 2L:
return "FALSE_EDGE";
3294 case 3L:
return "BACK_EDGE";
3295 case 4L:
return "MULTIWAY_EDGE";
3296 case 5L:
return "BREAK_EDGE";
3297 case 6L:
return "CONTINUE_EDGE";
3298 case 7L:
return "RETURN_EDGE";
3303 std::string
EdgeType(int64_t i,
const std::string &strip) {
3306 s =
"(CFG::EdgeType)" + boost::lexical_cast<std::string>(i);
3307 if (boost::starts_with(s, strip))
3308 s = s.substr(strip.size());
3313 static const int64_t values[] = {
3323 static const std::vector<int64_t> retval(values, values + 8);
3330 std::string stringifyCFG_EdgeType(int64_t i,
const char *strip,
bool canonic) {
3332 if (retval.empty()) {
3333 retval =
"(CFG::EdgeType)" + boost::lexical_cast<std::string>(i);
3335 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3336 retval = retval.substr(strlen(strip));
3338 retval =
"CFG::EdgeType::" + retval;
3343 const std::vector<int64_t>& stringifyCFG_EdgeType() {
3353 case 0L:
return "ED_INCOMING";
3354 case 1L:
return "ED_OUTGOING";
3362 s =
"(RIFG::EdgeDirection)" + boost::lexical_cast<std::string>(i);
3363 if (boost::starts_with(s, strip))
3364 s = s.substr(strip.size());
3369 static const int64_t values[] = {
3373 static const std::vector<int64_t> retval(values, values + 2);
3380 std::string stringifyRIFG_EdgeDirection(int64_t i,
const char *strip,
bool canonic) {
3382 if (retval.empty()) {
3383 retval =
"(RIFG::EdgeDirection)" + boost::lexical_cast<std::string>(i);
3385 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3386 retval = retval.substr(strlen(strip));
3388 retval =
"RIFG::EdgeDirection::" + retval;
3393 const std::vector<int64_t>& stringifyRIFG_EdgeDirection() {
3403 case 0L:
return "FORWARD";
3404 case 1L:
return "BACKWARD";
3412 s =
"(RIFG::ForwardBackward)" + boost::lexical_cast<std::string>(i);
3413 if (boost::starts_with(s, strip))
3414 s = s.substr(strip.size());
3419 static const int64_t values[] = {
3423 static const std::vector<int64_t> retval(values, values + 2);
3430 std::string stringifyRIFG_ForwardBackward(int64_t i,
const char *strip,
bool canonic) {
3432 if (retval.empty()) {
3433 retval =
"(RIFG::ForwardBackward)" + boost::lexical_cast<std::string>(i);
3435 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3436 retval = retval.substr(strlen(strip));
3438 retval =
"RIFG::ForwardBackward::" + retval;
3443 const std::vector<int64_t>& stringifyRIFG_ForwardBackward() {
3453 case 0L:
return "RI_TARJ_NOTHING";
3454 case 1L:
return "RI_TARJ_ACYCLIC";
3455 case 2L:
return "RI_TARJ_INTERVAL";
3456 case 3L:
return "RI_TARJ_IRREDUCIBLE";
3464 s =
"(RITarjType)" + boost::lexical_cast<std::string>(i);
3465 if (boost::starts_with(s, strip))
3466 s = s.substr(strip.size());
3471 static const int64_t values[] = {
3477 static const std::vector<int64_t> retval(values, values + 4);
3484 std::string stringifyRITarjType(int64_t i,
const char *strip,
bool canonic) {
3486 if (retval.empty()) {
3487 retval =
"(RITarjType)" + boost::lexical_cast<std::string>(i);
3489 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3490 retval = retval.substr(strlen(strip));
3492 retval =
"RITarjType::" + retval;
3497 const std::vector<int64_t>& stringifyRITarjType() {
3507 case 0L:
return "RI_TARJ_NORMAL";
3508 case 1L:
return "RI_TARJ_LOOP_ENTRY";
3509 case 2L:
return "RI_TARJ_IRRED_ENTRY";
3510 case 3L:
return "RI_TARJ_ITERATE";
3518 s =
"(RITarjEdgeType)" + boost::lexical_cast<std::string>(i);
3519 if (boost::starts_with(s, strip))
3520 s = s.substr(strip.size());
3525 static const int64_t values[] = {
3531 static const std::vector<int64_t> retval(values, values + 4);
3538 std::string stringifyRITarjEdgeType(int64_t i,
const char *strip,
bool canonic) {
3540 if (retval.empty()) {
3541 retval =
"(RITarjEdgeType)" + boost::lexical_cast<std::string>(i);
3543 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3544 retval = retval.substr(strlen(strip));
3546 retval =
"RITarjEdgeType::" + retval;
3551 const std::vector<int64_t>& stringifyRITarjEdgeType() {
3558 namespace stringify {
namespace CallGraph {
3561 case 0L:
return "NORMAL_EDGE";
3566 std::string
EdgeType(int64_t i,
const std::string &strip) {
3569 s =
"(CallGraph::EdgeType)" + boost::lexical_cast<std::string>(i);
3570 if (boost::starts_with(s, strip))
3571 s = s.substr(strip.size());
3576 static const int64_t values[] = {
3579 static const std::vector<int64_t> retval(values, values + 1);
3586 std::string stringifyCallGraphEdgeType(int64_t i,
const char *strip,
bool canonic) {
3588 if (retval.empty()) {
3589 retval =
"(CallGraph::EdgeType)" + boost::lexical_cast<std::string>(i);
3591 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3592 retval = retval.substr(strlen(strip));
3594 retval =
"CallGraph::EdgeType::" + retval;
3599 const std::vector<int64_t>& stringifyCallGraphEdgeType() {
3606 namespace stringify {
namespace BaseGraph {
namespace BiDirNodesIterator {
3609 case 0L:
return "Forward";
3610 case 1L:
return "Reverse";
3615 std::string
dirType(int64_t i,
const std::string &strip) {
3618 s =
"(BaseGraph::BiDirNodesIterator::dirType)" + boost::lexical_cast<std::string>(i);
3619 if (boost::starts_with(s, strip))
3620 s = s.substr(strip.size());
3625 static const int64_t values[] = {
3629 static const std::vector<int64_t> retval(values, values + 2);
3636 std::string stringifyBaseGraphBiDirNodesIterator_dirType(int64_t i,
const char *strip,
bool canonic) {
3638 if (retval.empty()) {
3639 retval =
"(BaseGraph::BiDirNodesIterator::dirType)" + boost::lexical_cast<std::string>(i);
3641 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3642 retval = retval.substr(strlen(strip));
3644 retval =
"BaseGraph::BiDirNodesIterator::dirType::" + retval;
3649 const std::vector<int64_t>& stringifyBaseGraphBiDirNodesIterator_dirType() {
3659 case 0L:
return "ProcType_PGM";
3660 case 1L:
return "ProcType_SUB";
3661 case 2L:
return "ProcType_FUNC";
3662 case 3L:
return "ProcType_BDATA";
3663 case 4L:
return "ProcType_ILLEGAL";
3671 s =
"(IRProcType)" + boost::lexical_cast<std::string>(i);
3672 if (boost::starts_with(s, strip))
3673 s = s.substr(strip.size());
3678 static const int64_t values[] = {
3685 static const std::vector<int64_t> retval(values, values + 5);
3692 std::string stringifyIRProcType(int64_t i,
const char *strip,
bool canonic) {
3694 if (retval.empty()) {
3695 retval =
"(IRProcType)" + boost::lexical_cast<std::string>(i);
3697 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3698 retval = retval.substr(strlen(strip));
3700 retval =
"IRProcType::" + retval;
3705 const std::vector<int64_t>& stringifyIRProcType() {
3715 case 0L:
return "SIMPLE";
3716 case 1L:
return "COMPOUND";
3717 case 2L:
return "LOOP";
3718 case 3L:
return "END_TESTED_LOOP";
3719 case 4L:
return "STRUCT_TWOWAY_CONDITIONAL";
3720 case 5L:
return "STRUCT_MULTIWAY_CONDITIONAL";
3721 case 6L:
return "USTRUCT_TWOWAY_CONDITIONAL_T";
3722 case 7L:
return "USTRUCT_TWOWAY_CONDITIONAL_F";
3723 case 8L:
return "USTRUCT_MULTIWAY_CONDITIONAL";
3724 case 9L:
return "RETURN";
3725 case 10L:
return "BREAK";
3726 case 11L:
return "LOOP_CONTINUE";
3727 case 12L:
return "ALTERNATE_PROC_ENTRY";
3728 case 13L:
return "UNCONDITIONAL_JUMP";
3729 case 14L:
return "UNCONDITIONAL_JUMP_I";
3730 case 15L:
return "NONE";
3738 s =
"(IRStmtType)" + boost::lexical_cast<std::string>(i);
3739 if (boost::starts_with(s, strip))
3740 s = s.substr(strip.size());
3745 static const int64_t values[] = {
3763 static const std::vector<int64_t> retval(values, values + 16);
3770 std::string stringifyIRStmtType(int64_t i,
const char *strip,
bool canonic) {
3772 if (retval.empty()) {
3773 retval =
"(IRStmtType)" + boost::lexical_cast<std::string>(i);
3775 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3776 retval = retval.substr(strlen(strip));
3778 retval =
"IRStmtType::" + retval;
3783 const std::vector<int64_t>& stringifyIRStmtType() {
3790 namespace stringify {
namespace PtrAliasAnalysis {
3793 case 0L:
return "WHITE";
3794 case 1L:
return "GREY";
3795 case 2L:
return "BLACK";
3800 std::string
COLOR(int64_t i,
const std::string &strip) {
3801 std::string s =
COLOR(i);
3803 s =
"(PtrAliasAnalysis::COLOR)" + boost::lexical_cast<std::string>(i);
3804 if (boost::starts_with(s, strip))
3805 s = s.substr(strip.size());
3810 static const int64_t values[] = {
3815 static const std::vector<int64_t> retval(values, values + 3);
3822 std::string stringifyPtrAliasAnalysisCOLOR(int64_t i,
const char *strip,
bool canonic) {
3824 if (retval.empty()) {
3825 retval =
"(PtrAliasAnalysis::COLOR)" + boost::lexical_cast<std::string>(i);
3827 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3828 retval = retval.substr(strlen(strip));
3830 retval =
"PtrAliasAnalysis::COLOR::" + retval;
3835 const std::vector<int64_t>& stringifyPtrAliasAnalysisCOLOR() {
3842 namespace stringify {
namespace PtrAliasAnalysis {
3845 case 0L:
return "TOPOLOGICAL";
3846 case 1L:
return "REVERSE_TOPOLOGICAL";
3854 s =
"(PtrAliasAnalysis::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
3855 if (boost::starts_with(s, strip))
3856 s = s.substr(strip.size());
3861 static const int64_t values[] = {
3865 static const std::vector<int64_t> retval(values, values + 2);
3872 std::string stringifyPtrAliasAnalysisTRAVERSAL_TYPE(int64_t i,
const char *strip,
bool canonic) {
3874 if (retval.empty()) {
3875 retval =
"(PtrAliasAnalysis::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
3877 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3878 retval = retval.substr(strlen(strip));
3880 retval =
"PtrAliasAnalysis::TRAVERSAL_TYPE::" + retval;
3885 const std::vector<int64_t>& stringifyPtrAliasAnalysisTRAVERSAL_TYPE() {
3892 namespace stringify {
namespace CollectAliasRelations {
3895 case 0L:
return "WHITE";
3896 case 1L:
return "GREY";
3897 case 2L:
return "BLACK";
3902 std::string
COLOR(int64_t i,
const std::string &strip) {
3903 std::string s =
COLOR(i);
3905 s =
"(CollectAliasRelations::COLOR)" + boost::lexical_cast<std::string>(i);
3906 if (boost::starts_with(s, strip))
3907 s = s.substr(strip.size());
3912 static const int64_t values[] = {
3917 static const std::vector<int64_t> retval(values, values + 3);
3924 std::string stringifyCollectAliasRelationsCOLOR(int64_t i,
const char *strip,
bool canonic) {
3926 if (retval.empty()) {
3927 retval =
"(CollectAliasRelations::COLOR)" + boost::lexical_cast<std::string>(i);
3929 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3930 retval = retval.substr(strlen(strip));
3932 retval =
"CollectAliasRelations::COLOR::" + retval;
3937 const std::vector<int64_t>& stringifyCollectAliasRelationsCOLOR() {
3944 namespace stringify {
namespace CollectAliasRelations {
3947 case 0L:
return "TOPOLOGICAL";
3948 case 1L:
return "NON_TOPOLOGICAL";
3956 s =
"(CollectAliasRelations::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
3957 if (boost::starts_with(s, strip))
3958 s = s.substr(strip.size());
3963 static const int64_t values[] = {
3967 static const std::vector<int64_t> retval(values, values + 2);
3974 std::string stringifyCollectAliasRelationsTRAVERSAL_TYPE(int64_t i,
const char *strip,
bool canonic) {
3976 if (retval.empty()) {
3977 retval =
"(CollectAliasRelations::TRAVERSAL_TYPE)" + boost::lexical_cast<std::string>(i);
3979 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
3980 retval = retval.substr(strlen(strip));
3982 retval =
"CollectAliasRelations::TRAVERSAL_TYPE::" + retval;
3987 const std::vector<int64_t>& stringifyCollectAliasRelationsTRAVERSAL_TYPE() {
3994 namespace stringify {
namespace DominatorTreesAndDominanceFrontiers {
namespace DominatorTree {
3997 case 0L:
return "PRE";
3998 case 1L:
return "POST";
4003 std::string
Direction(int64_t i,
const std::string &strip) {
4006 s =
"(DominatorTreesAndDominanceFrontiers::DominatorTree::Direction)" + boost::lexical_cast<std::string>(i);
4007 if (boost::starts_with(s, strip))
4008 s = s.substr(strip.size());
4013 static const int64_t values[] = {
4017 static const std::vector<int64_t> retval(values, values + 2);
4024 std::string stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection(int64_t i,
const char *strip,
bool canonic) {
4026 if (retval.empty()) {
4027 retval =
"(DominatorTreesAndDominanceFrontiers::DominatorTree::Direction)" + boost::lexical_cast<std::string>(i);
4029 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4030 retval = retval.substr(strlen(strip));
4032 retval =
"DominatorTreesAndDominanceFrontiers::DominatorTree::Direction::" + retval;
4037 const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDominatorTreeDirection() {
4047 case 0L:
return "PHI_FUNCTION";
4048 case 1L:
return "ORIGINAL_DEF";
4049 case 2L:
return "EXPANDED_DEF";
4054 std::string
Type(int64_t i,
const std::string &strip) {
4055 std::string s =
Type(i);
4057 s =
"(ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
4058 if (boost::starts_with(s, strip))
4059 s = s.substr(strip.size());
4063 const std::vector<int64_t>&
Type() {
4064 static const int64_t values[] = {
4069 static const std::vector<int64_t> retval(values, values + 3);
4076 std::string stringifyReachingDefType(int64_t i,
const char *strip,
bool canonic) {
4078 if (retval.empty()) {
4079 retval =
"(ReachingDef::Type)" + boost::lexical_cast<std::string>(i);
4081 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4082 retval = retval.substr(strlen(strip));
4084 retval =
"ReachingDef::Type::" + retval;
4089 const std::vector<int64_t>& stringifyReachingDefType() {
4096 namespace stringify {
namespace ArithmeticIntensityMeasurement {
4099 case 0L:
return "e_analysis_and_instrument";
4100 case 1L:
return "e_static_counting";
4108 s =
"(ArithmeticIntensityMeasurement::running_mode_enum)" + boost::lexical_cast<std::string>(i);
4109 if (boost::starts_with(s, strip))
4110 s = s.substr(strip.size());
4115 static const int64_t values[] = {
4119 static const std::vector<int64_t> retval(values, values + 2);
4126 std::string stringifyArithmeticIntensityMeasurement_running_mode_enum(int64_t i,
const char *strip,
bool canonic) {
4128 if (retval.empty()) {
4129 retval =
"(ArithmeticIntensityMeasurement::running_mode_enum)" + boost::lexical_cast<std::string>(i);
4131 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4132 retval = retval.substr(strlen(strip));
4134 retval =
"ArithmeticIntensityMeasurement::running_mode_enum::" + retval;
4139 const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_running_mode_enum() {
4146 namespace stringify {
namespace ArithmeticIntensityMeasurement {
4149 case 0L:
return "e_unknown";
4150 case 1L:
return "e_total";
4151 case 2L:
return "e_plus";
4152 case 3L:
return "e_minus";
4153 case 4L:
return "e_multiply";
4154 case 5L:
return "e_divide";
4162 s =
"(ArithmeticIntensityMeasurement::fp_operation_kind_enum)" + boost::lexical_cast<std::string>(i);
4163 if (boost::starts_with(s, strip))
4164 s = s.substr(strip.size());
4169 static const int64_t values[] = {
4177 static const std::vector<int64_t> retval(values, values + 6);
4184 std::string stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum(int64_t i,
const char *strip,
bool canonic) {
4186 if (retval.empty()) {
4187 retval =
"(ArithmeticIntensityMeasurement::fp_operation_kind_enum)" + boost::lexical_cast<std::string>(i);
4189 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4190 retval = retval.substr(strlen(strip));
4192 retval =
"ArithmeticIntensityMeasurement::fp_operation_kind_enum::" + retval;
4197 const std::vector<int64_t>& stringifyArithmeticIntensityMeasurement_fp_operation_kind_enum() {
4204 namespace stringify {
namespace SDG {
namespace PDGEdge {
4207 case 0L:
return "ControlDependence";
4208 case 1L:
return "DataDependence";
4213 std::string
EdgeType(int64_t i,
const std::string &strip) {
4216 s =
"(SDG::PDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
4217 if (boost::starts_with(s, strip))
4218 s = s.substr(strip.size());
4223 static const int64_t values[] = {
4227 static const std::vector<int64_t> retval(values, values + 2);
4234 std::string stringifySDG_PDGEdgeEdgeType(int64_t i,
const char *strip,
bool canonic) {
4236 if (retval.empty()) {
4237 retval =
"(SDG::PDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
4239 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4240 retval = retval.substr(strlen(strip));
4242 retval =
"SDG::PDGEdge::EdgeType::" + retval;
4247 const std::vector<int64_t>& stringifySDG_PDGEdgeEdgeType() {
4254 namespace stringify {
namespace SDG {
namespace SDGNode {
4257 case 0L:
return "Entry";
4258 case 1L:
return "ASTNode";
4259 case 2L:
return "FunctionCall";
4260 case 3L:
return "ActualIn";
4261 case 4L:
return "ActualOut";
4262 case 5L:
return "FormalIn";
4263 case 6L:
return "FormalOut";
4268 std::string
NodeType(int64_t i,
const std::string &strip) {
4271 s =
"(SDG::SDGNode::NodeType)" + boost::lexical_cast<std::string>(i);
4272 if (boost::starts_with(s, strip))
4273 s = s.substr(strip.size());
4278 static const int64_t values[] = {
4287 static const std::vector<int64_t> retval(values, values + 7);
4294 std::string stringifySDG_SDGNodeNodeType(int64_t i,
const char *strip,
bool canonic) {
4296 if (retval.empty()) {
4297 retval =
"(SDG::SDGNode::NodeType)" + boost::lexical_cast<std::string>(i);
4299 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4300 retval = retval.substr(strlen(strip));
4302 retval =
"SDG::SDGNode::NodeType::" + retval;
4307 const std::vector<int64_t>& stringifySDG_SDGNodeNodeType() {
4314 namespace stringify {
namespace SDG {
namespace SDGEdge {
4317 case 0L:
return "ControlDependence";
4318 case 1L:
return "DataDependence";
4319 case 2L:
return "ParameterIn";
4320 case 3L:
return "ParameterOut";
4321 case 4L:
return "Call";
4322 case 5L:
return "Summary";
4327 std::string
EdgeType(int64_t i,
const std::string &strip) {
4330 s =
"(SDG::SDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
4331 if (boost::starts_with(s, strip))
4332 s = s.substr(strip.size());
4337 static const int64_t values[] = {
4345 static const std::vector<int64_t> retval(values, values + 6);
4352 std::string stringifySDG_SDGEdgeEdgeType(int64_t i,
const char *strip,
bool canonic) {
4354 if (retval.empty()) {
4355 retval =
"(SDG::SDGEdge::EdgeType)" + boost::lexical_cast<std::string>(i);
4357 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4358 retval = retval.substr(strlen(strip));
4360 retval =
"SDG::SDGEdge::EdgeType::" + retval;
4365 const std::vector<int64_t>& stringifySDG_SDGEdgeEdgeType() {
4372 namespace stringify {
namespace SDG {
namespace SDGEdge {
4375 case 0L:
return "cdTrue";
4376 case 1L:
return "cdFalse";
4377 case 2L:
return "cdCase";
4378 case 3L:
return "cdDefault";
4386 s =
"(SDG::SDGEdge::ControlDependenceType)" + boost::lexical_cast<std::string>(i);
4387 if (boost::starts_with(s, strip))
4388 s = s.substr(strip.size());
4393 static const int64_t values[] = {
4399 static const std::vector<int64_t> retval(values, values + 4);
4406 std::string stringifySDG_SDGEdgeControlDependenceType(int64_t i,
const char *strip,
bool canonic) {
4408 if (retval.empty()) {
4409 retval =
"(SDG::SDGEdge::ControlDependenceType)" + boost::lexical_cast<std::string>(i);
4411 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4412 retval = retval.substr(strlen(strip));
4414 retval =
"SDG::SDGEdge::ControlDependenceType::" + retval;
4419 const std::vector<int64_t>& stringifySDG_SDGEdgeControlDependenceType() {
4426 namespace stringify {
namespace DominatorTreesAndDominanceFrontiers {
4429 case 0L:
return "PRE_DOMINATOR";
4430 case 1L:
return "POST_DOMINATOR";
4438 s =
"(DominatorTreesAndDominanceFrontiers::Dir_ection)" + boost::lexical_cast<std::string>(i);
4439 if (boost::starts_with(s, strip))
4440 s = s.substr(strip.size());
4445 static const int64_t values[] = {
4449 static const std::vector<int64_t> retval(values, values + 2);
4456 std::string stringifyDominatorTreesAndDominanceFrontiersDir_ection(int64_t i,
const char *strip,
bool canonic) {
4458 if (retval.empty()) {
4459 retval =
"(DominatorTreesAndDominanceFrontiers::Dir_ection)" + boost::lexical_cast<std::string>(i);
4461 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4462 retval = retval.substr(strlen(strip));
4464 retval =
"DominatorTreesAndDominanceFrontiers::Dir_ection::" + retval;
4469 const std::vector<int64_t>& stringifyDominatorTreesAndDominanceFrontiersDir_ection() {
4476 namespace stringify {
namespace MidLevelCollectionTypedefs {
4479 case 0L:
return "unknownScope";
4480 case 1L:
return "StatementScope";
4481 case 2L:
return "SurroundingScope";
4482 case 3L:
return "Preamble";
4483 case 4L:
return "LAST_SCOPE_TAG";
4491 s =
"(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
4492 if (boost::starts_with(s, strip))
4493 s = s.substr(strip.size());
4498 static const int64_t values[] = {
4505 static const std::vector<int64_t> retval(values, values + 5);
4512 std::string stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i,
const char *strip,
bool canonic) {
4514 if (retval.empty()) {
4515 retval =
"(MidLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
4517 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4518 retval = retval.substr(strlen(strip));
4520 retval =
"MidLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
4525 const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsScopeIdentifier_Enum() {
4532 namespace stringify {
namespace MidLevelCollectionTypedefs {
4535 case 0L:
return "unknownPositionInScope";
4536 case 1L:
return "PreamblePositionInScope";
4537 case 2L:
return "TopOfCurrentScope";
4538 case 3L:
return "BeforeCurrentPosition";
4539 case 4L:
return "ReplaceCurrentPosition";
4540 case 5L:
return "AfterCurrentPosition";
4541 case 6L:
return "BottomOfCurrentScope";
4542 case 7L:
return "LAST_PLACEMENT_TAG";
4550 s =
"(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
4551 if (boost::starts_with(s, strip))
4552 s = s.substr(strip.size());
4557 static const int64_t values[] = {
4567 static const std::vector<int64_t> retval(values, values + 8);
4574 std::string stringifyMidLevelCollectionTypedefsPlacementPosition_Enum(int64_t i,
const char *strip,
bool canonic) {
4576 if (retval.empty()) {
4577 retval =
"(MidLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
4579 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4580 retval = retval.substr(strlen(strip));
4582 retval =
"MidLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
4587 const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsPlacementPosition_Enum() {
4594 namespace stringify {
namespace MidLevelCollectionTypedefs {
4597 case 0L:
return "unknownIntermediatePositionInScope";
4598 case 1L:
return "GlobalScopePreamble";
4599 case 2L:
return "CurrentLocationTopOfScope";
4600 case 3L:
return "CurrentLocationAfter";
4601 case 4L:
return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
4602 case 6L:
return "CurrentLocationBottomOfScope";
4610 s =
"(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
4611 if (boost::starts_with(s, strip))
4612 s = s.substr(strip.size());
4617 static const int64_t values[] = {
4625 static const std::vector<int64_t> retval(values, values + 6);
4632 std::string stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i,
const char *strip,
bool canonic) {
4634 if (retval.empty()) {
4635 retval =
"(MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
4637 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4638 retval = retval.substr(strlen(strip));
4640 retval =
"MidLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
4645 const std::vector<int64_t>& stringifyMidLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
4652 namespace stringify {
namespace HighLevelCollectionTypedefs {
4655 case 0L:
return "unknownScope";
4656 case 1L:
return "SurroundingScope";
4657 case 2L:
return "ParentScope";
4658 case 3L:
return "NestedLoopScope";
4659 case 4L:
return "NestedConditionalScope";
4660 case 5L:
return "FunctionScope";
4661 case 6L:
return "FileScope";
4662 case 7L:
return "GlobalScope";
4663 case 8L:
return "Preamble";
4664 case 9L:
return "LAST_SCOPE_TAG";
4672 s =
"(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
4673 if (boost::starts_with(s, strip))
4674 s = s.substr(strip.size());
4679 static const int64_t values[] = {
4691 static const std::vector<int64_t> retval(values, values + 10);
4698 std::string stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum(int64_t i,
const char *strip,
bool canonic) {
4700 if (retval.empty()) {
4701 retval =
"(HighLevelCollectionTypedefs::ScopeIdentifier_Enum)" + boost::lexical_cast<std::string>(i);
4703 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4704 retval = retval.substr(strlen(strip));
4706 retval =
"HighLevelCollectionTypedefs::ScopeIdentifier_Enum::" + retval;
4711 const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsScopeIdentifier_Enum() {
4718 namespace stringify {
namespace HighLevelCollectionTypedefs {
4721 case 0L:
return "unknownPositionInScope";
4722 case 1L:
return "PreamblePositionInScope";
4723 case 2L:
return "TopOfScope";
4724 case 3L:
return "TopOfIncludeRegion";
4725 case 4L:
return "BottomOfIncludeRegion";
4726 case 5L:
return "BeforeCurrentPosition";
4727 case 6L:
return "ReplaceCurrentPosition";
4728 case 7L:
return "AfterCurrentPosition";
4729 case 8L:
return "BottomOfScope";
4730 case 9L:
return "LAST_PLACEMENT_TAG";
4738 s =
"(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
4739 if (boost::starts_with(s, strip))
4740 s = s.substr(strip.size());
4745 static const int64_t values[] = {
4757 static const std::vector<int64_t> retval(values, values + 10);
4764 std::string stringifyHighLevelCollectionTypedefsPlacementPosition_Enum(int64_t i,
const char *strip,
bool canonic) {
4766 if (retval.empty()) {
4767 retval =
"(HighLevelCollectionTypedefs::PlacementPosition_Enum)" + boost::lexical_cast<std::string>(i);
4769 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4770 retval = retval.substr(strlen(strip));
4772 retval =
"HighLevelCollectionTypedefs::PlacementPosition_Enum::" + retval;
4777 const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsPlacementPosition_Enum() {
4784 namespace stringify {
namespace HighLevelCollectionTypedefs {
4787 case 0L:
return "unknownIntermediatePositionInScope";
4788 case 1L:
return "GlobalScopePreamble";
4789 case 2L:
return "GlobalScopeTopOfScope";
4790 case 3L:
return "GlobalScopeTopOfIncludeRegion";
4791 case 4L:
return "GlobalScopeBottomOfIncludeRegion";
4792 case 5L:
return "GlobalScopeBeforeCurrentPosition";
4793 case 6L:
return "GlobalScopeReplaceCurrentPosition";
4794 case 7L:
return "FunctionScopePreamble";
4795 case 8L:
return "FunctionScopeTopOfScope";
4796 case 9L:
return "FunctionScopeBeforeCurrentPosition";
4797 case 10L:
return "FunctionScopeReplaceCurrentPosition";
4798 case 11L:
return "FunctionScopeAfterCurrentPosition";
4799 case 12L:
return "FunctionScopeBottomOfScope";
4800 case 13L:
return "GlobalScopeAfterCurrentPosition";
4801 case 14L:
return "GlobalScopeBottomOfScope";
4802 case 15L:
return "LAST_INTERMEDIATE_SOURCE_CODE_PLACEMENT_TAG";
4810 s =
"(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
4811 if (boost::starts_with(s, strip))
4812 s = s.substr(strip.size());
4817 static const int64_t values[] = {
4835 static const std::vector<int64_t> retval(values, values + 16);
4842 std::string stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum(int64_t i,
const char *strip,
bool canonic) {
4844 if (retval.empty()) {
4845 retval =
"(HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum)" + boost::lexical_cast<std::string>(i);
4847 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4848 retval = retval.substr(strlen(strip));
4850 retval =
"HighLevelCollectionTypedefs::IntermediateFileStringPosition_Enum::" + retval;
4855 const std::vector<int64_t>& stringifyHighLevelCollectionTypedefsIntermediateFileStringPosition_Enum() {
4865 case 0L:
return "INSERT_BODY";
4866 case 1L:
return "INSERT_STMTS";
4874 s =
"(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
4875 if (boost::starts_with(s, strip))
4876 s = s.substr(strip.size());
4881 static const int64_t values[] = {
4885 static const std::vector<int64_t> retval(values, values + 2);
4892 std::string stringifySnippetInsertMechanism(int64_t i,
const char *strip,
bool canonic) {
4894 if (retval.empty()) {
4895 retval =
"(Rose::Snippet::InsertMechanism)" + boost::lexical_cast<std::string>(i);
4897 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4898 retval = retval.substr(strlen(strip));
4900 retval =
"Rose::Snippet::InsertMechanism::" + retval;
4905 const std::vector<int64_t>& stringifySnippetInsertMechanism() {
4915 case 0L:
return "LOCDECLS_AT_BEGINNING";
4916 case 1L:
return "LOCDECLS_AT_END";
4917 case 2L:
return "LOCDECLS_AT_CURSOR";
4925 s =
"(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
4926 if (boost::starts_with(s, strip))
4927 s = s.substr(strip.size());
4932 static const int64_t values[] = {
4937 static const std::vector<int64_t> retval(values, values + 3);
4944 std::string stringifySnippetLocalDeclarationPosition(int64_t i,
const char *strip,
bool canonic) {
4946 if (retval.empty()) {
4947 retval =
"(Rose::Snippet::LocalDeclarationPosition)" + boost::lexical_cast<std::string>(i);
4949 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
4950 retval = retval.substr(strlen(strip));
4952 retval =
"Rose::Snippet::LocalDeclarationPosition::" + retval;
4957 const std::vector<int64_t>& stringifySnippetLocalDeclarationPosition() {
4964 namespace stringify {
namespace klt_tile_desc_t {
4967 case 0L:
return "e_tile_static";
4968 case 1L:
return "e_tile_dynamic";
4976 s =
"(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
4977 if (boost::starts_with(s, strip))
4978 s = s.substr(strip.size());
4983 static const int64_t values[] = {
4987 static const std::vector<int64_t> retval(values, values + 2);
4994 std::string stringify_klt_tile_desc_t_tile_kind_e(int64_t i,
const char *strip,
bool canonic) {
4996 if (retval.empty()) {
4997 retval =
"(klt_tile_desc_t::tile_kind_e)" + boost::lexical_cast<std::string>(i);
4999 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5000 retval = retval.substr(strlen(strip));
5002 retval =
"klt_tile_desc_t::tile_kind_e::" + retval;
5007 const std::vector<int64_t>& stringify_klt_tile_desc_t_tile_kind_e() {
5014 namespace stringify {
namespace KLT {
namespace LoopTree {
5017 case 0L:
return "e_block";
5018 case 1L:
return "e_cond";
5019 case 2L:
return "e_loop";
5020 case 3L:
return "e_tile";
5021 case 4L:
return "e_stmt";
5022 case 5L:
return "e_ignored";
5023 case 6L:
return "e_unknown";
5028 std::string
kind_e(int64_t i,
const std::string &strip) {
5029 std::string s =
kind_e(i);
5031 s =
"(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
5032 if (boost::starts_with(s, strip))
5033 s = s.substr(strip.size());
5038 static const int64_t values[] = {
5047 static const std::vector<int64_t> retval(values, values + 7);
5054 std::string stringifyKLT_LoopTree_kind_e(int64_t i,
const char *strip,
bool canonic) {
5056 if (retval.empty()) {
5057 retval =
"(KLT::LoopTree::kind_e)" + boost::lexical_cast<std::string>(i);
5059 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5060 retval = retval.substr(strlen(strip));
5062 retval =
"KLT::LoopTree::kind_e::" + retval;
5067 const std::vector<int64_t>& stringifyKLT_LoopTree_kind_e() {
5074 namespace stringify {
namespace KLT {
namespace Descriptor {
5077 case -1L:
return "e_not_tile";
5078 case 0L:
return "e_static_tile";
5079 case 1L:
return "e_last_klt_tile";
5087 s =
"(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
5088 if (boost::starts_with(s, strip))
5089 s = s.substr(strip.size());
5094 static const int64_t values[] = {
5099 static const std::vector<int64_t> retval(values, values + 3);
5106 std::string stringifyKLT_Descriptor_tile_kind_e(int64_t i,
const char *strip,
bool canonic) {
5108 if (retval.empty()) {
5109 retval =
"(KLT::Descriptor::tile_kind_e)" + boost::lexical_cast<std::string>(i);
5111 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5112 retval = retval.substr(strlen(strip));
5114 retval =
"KLT::Descriptor::tile_kind_e::" + retval;
5119 const std::vector<int64_t>& stringifyKLT_Descriptor_tile_kind_e() {
5126 namespace stringify {
namespace AbstractMemoryObject {
namespace IndexSet {
5129 case 0L:
return "Integer_type";
5130 case 1L:
return "Unknown_type";
5138 s =
"(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
5139 if (boost::starts_with(s, strip))
5140 s = s.substr(strip.size());
5145 static const int64_t values[] = {
5149 static const std::vector<int64_t> retval(values, values + 2);
5156 std::string stringifyAbstractMemoryObjectIndexSetIndex_type(int64_t i,
const char *strip,
bool canonic) {
5158 if (retval.empty()) {
5159 retval =
"(AbstractMemoryObject::IndexSet::Index_type)" + boost::lexical_cast<std::string>(i);
5161 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5162 retval = retval.substr(strlen(strip));
5164 retval =
"AbstractMemoryObject::IndexSet::Index_type::" + retval;
5169 const std::vector<int64_t>& stringifyAbstractMemoryObjectIndexSetIndex_type() {
5176 namespace stringify {
namespace MDCG {
namespace Model {
5179 case 0L:
return "e_model_blank";
5180 case 1L:
return "e_model_variable";
5181 case 2L:
return "e_model_function";
5182 case 3L:
return "e_model_field";
5183 case 4L:
return "e_model_method";
5184 case 5L:
return "e_model_type";
5185 case 6L:
return "e_model_class";
5186 case 7L:
return "e_model_namespace";
5194 s =
"(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
5195 if (boost::starts_with(s, strip))
5196 s = s.substr(strip.size());
5201 static const int64_t values[] = {
5211 static const std::vector<int64_t> retval(values, values + 8);
5218 std::string stringifyMDCG_Model_model_elements_e(int64_t i,
const char *strip,
bool canonic) {
5220 if (retval.empty()) {
5221 retval =
"(MDCG::Model::model_elements_e)" + boost::lexical_cast<std::string>(i);
5223 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5224 retval = retval.substr(strlen(strip));
5226 retval =
"MDCG::Model::model_elements_e::" + retval;
5231 const std::vector<int64_t>& stringifyMDCG_Model_model_elements_e() {
5238 namespace stringify {
namespace MDCG {
namespace Model {
namespace element_t {
5241 case 0L:
return "kind";
5246 std::string
kind_e(int64_t i,
const std::string &strip) {
5247 std::string s =
kind_e(i);
5249 s =
"(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
5250 if (boost::starts_with(s, strip))
5251 s = s.substr(strip.size());
5256 static const int64_t values[] = {
5259 static const std::vector<int64_t> retval(values, values + 1);
5266 std::string stringifyMDCG_Model_element_t_kind_e(int64_t i,
const char *strip,
bool canonic) {
5268 if (retval.empty()) {
5269 retval =
"(MDCG::Model::element_t::kind_e)" + boost::lexical_cast<std::string>(i);
5271 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5272 retval = retval.substr(strlen(strip));
5274 retval =
"MDCG::Model::element_t::kind_e::" + retval;
5279 const std::vector<int64_t>& stringifyMDCG_Model_element_t_kind_e() {
5286 namespace stringify {
namespace NumberQuery {
5289 case 0L:
return "UnknownListElementType";
5290 case 1L:
return "NumberOfArgsInConstructor";
5291 case 2L:
return "NumberOfOperands";
5292 case 3L:
return "NumberOfArgsInScalarIndexingOperator";
5293 case 4L:
return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
5301 s =
"(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5302 if (boost::starts_with(s, strip))
5303 s = s.substr(strip.size());
5308 static const int64_t values[] = {
5315 static const std::vector<int64_t> retval(values, values + 5);
5322 std::string stringifyNumberQueryTypeOfQueryTypeOneParameter(int64_t i,
const char *strip,
bool canonic) {
5324 if (retval.empty()) {
5325 retval =
"(NumberQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5327 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5328 retval = retval.substr(strlen(strip));
5330 retval =
"NumberQuery::TypeOfQueryTypeOneParameter::" + retval;
5335 const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeOneParameter() {
5342 namespace stringify {
namespace NumberQuery {
5345 case 0L:
return "UnknownListElementTypeTwoParameters";
5346 case 1L:
return "NumberOfArgsInParanthesisOperator";
5347 case 2L:
return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
5355 s =
"(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5356 if (boost::starts_with(s, strip))
5357 s = s.substr(strip.size());
5362 static const int64_t values[] = {
5367 static const std::vector<int64_t> retval(values, values + 3);
5374 std::string stringifyNumberQueryTypeOfQueryTypeTwoParameters(int64_t i,
const char *strip,
bool canonic) {
5376 if (retval.empty()) {
5377 retval =
"(NumberQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5379 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5380 retval = retval.substr(strlen(strip));
5382 retval =
"NumberQuery::TypeOfQueryTypeTwoParameters::" + retval;
5387 const std::vector<int64_t>& stringifyNumberQueryTypeOfQueryTypeTwoParameters() {
5394 namespace stringify {
namespace BooleanQuery {
5397 case 0L:
return "UnknownListElementType";
5398 case 1L:
return "VariableDeclaration";
5399 case 2L:
return "Type";
5400 case 3L:
return "FunctionDeclaration";
5401 case 4L:
return "MemberFunctionDeclaration";
5402 case 5L:
return "ClassDeclaration";
5403 case 6L:
return "Argument";
5404 case 7L:
return "Field";
5405 case 8L:
return "UnionedField";
5406 case 9L:
return "Struct";
5407 case 10L:
return "ContainedInSubtreeOfType";
5408 case 11L:
return "END_OF_BOOLEAN_QUERY_TYPE";
5416 s =
"(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
5417 if (boost::starts_with(s, strip))
5418 s = s.substr(strip.size());
5423 static const int64_t values[] = {
5437 static const std::vector<int64_t> retval(values, values + 12);
5444 std::string stringifyBooleanQueryTypeOfQueryType(int64_t i,
const char *strip,
bool canonic) {
5446 if (retval.empty()) {
5447 retval =
"(BooleanQuery::TypeOfQueryType)" + boost::lexical_cast<std::string>(i);
5449 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5450 retval = retval.substr(strlen(strip));
5452 retval =
"BooleanQuery::TypeOfQueryType::" + retval;
5457 const std::vector<int64_t>& stringifyBooleanQueryTypeOfQueryType() {
5464 namespace stringify {
namespace AstQueryNamespace {
5467 case 0L:
return "UnknownListElementTypeQueryDepth";
5468 case 1L:
return "ChildrenOnly";
5469 case 2L:
return "AllNodes";
5470 case 3L:
return "ExtractTypes";
5471 case 4L:
return "END_OF_NODE_TYPE_LIST_QUERY_DEPTH";
5479 s =
"(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
5480 if (boost::starts_with(s, strip))
5481 s = s.substr(strip.size());
5486 static const int64_t values[] = {
5493 static const std::vector<int64_t> retval(values, values + 5);
5500 std::string stringifyAstQueryNamespaceQueryDepth(int64_t i,
const char *strip,
bool canonic) {
5502 if (retval.empty()) {
5503 retval =
"(AstQueryNamespace::QueryDepth)" + boost::lexical_cast<std::string>(i);
5505 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5506 retval = retval.substr(strlen(strip));
5508 retval =
"AstQueryNamespace::QueryDepth::" + retval;
5513 const std::vector<int64_t>& stringifyAstQueryNamespaceQueryDepth() {
5520 namespace stringify {
namespace NameQuery {
5523 case 0L:
return "UnknownListElementType";
5524 case 1L:
return "VariableNames";
5525 case 2L:
return "VariableTypeNames";
5526 case 3L:
return "FunctionDeclarationNames";
5527 case 4L:
return "MemberFunctionDeclarationNames";
5528 case 5L:
return "ClassDeclarationNames";
5529 case 6L:
return "ArgumentNames";
5530 case 7L:
return "ClassFieldNames";
5531 case 8L:
return "UnionFieldNames";
5532 case 9L:
return "StructFieldNames";
5533 case 10L:
return "FunctionReferenceNames";
5534 case 11L:
return "StructNames";
5535 case 12L:
return "UnionNames";
5536 case 13L:
return "TypedefDeclarationNames";
5537 case 14L:
return "TypeNames";
5538 case 15L:
return "END_OF_NAME_TYPE_LIST";
5546 s =
"(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5547 if (boost::starts_with(s, strip))
5548 s = s.substr(strip.size());
5553 static const int64_t values[] = {
5571 static const std::vector<int64_t> retval(values, values + 16);
5578 std::string stringifyNameQueryTypeOfQueryTypeOneParameter(int64_t i,
const char *strip,
bool canonic) {
5580 if (retval.empty()) {
5581 retval =
"(NameQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5583 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5584 retval = retval.substr(strlen(strip));
5586 retval =
"NameQuery::TypeOfQueryTypeOneParameter::" + retval;
5591 const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeOneParameter() {
5598 namespace stringify {
namespace NameQuery {
5601 case 0L:
return "UnknownListElementTypeTwoParameters";
5602 case 1L:
return "VariableNamesWithTypeName";
5603 case 2L:
return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
5611 s =
"(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5612 if (boost::starts_with(s, strip))
5613 s = s.substr(strip.size());
5618 static const int64_t values[] = {
5623 static const std::vector<int64_t> retval(values, values + 3);
5630 std::string stringifyNameQueryTypeOfQueryTypeTwoParameters(int64_t i,
const char *strip,
bool canonic) {
5632 if (retval.empty()) {
5633 retval =
"(NameQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5635 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5636 retval = retval.substr(strlen(strip));
5638 retval =
"NameQuery::TypeOfQueryTypeTwoParameters::" + retval;
5643 const std::vector<int64_t>& stringifyNameQueryTypeOfQueryTypeTwoParameters() {
5650 namespace stringify {
namespace NodeQuery {
5653 case 0L:
return "UnknownListElementType";
5654 case 1L:
return "VariableDeclarations";
5655 case 2L:
return "VariableTypes";
5656 case 3L:
return "FunctionDeclarations";
5657 case 4L:
return "MemberFunctionDeclarations";
5658 case 5L:
return "ClassDeclarations";
5659 case 6L:
return "StructDeclarations";
5660 case 7L:
return "UnionDeclarations";
5661 case 8L:
return "Arguments";
5662 case 9L:
return "ClassFields";
5663 case 10L:
return "StructFields";
5664 case 11L:
return "UnionFields";
5665 case 12L:
return "StructDefinitions";
5666 case 13L:
return "TypedefDeclarations";
5667 case 14L:
return "AnonymousTypedefs";
5668 case 15L:
return "AnonymousTypedefClassDeclarations";
5669 case 16L:
return "END_OF_NODE_TYPE_LIST_ONE_PARAMETER";
5677 s =
"(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5678 if (boost::starts_with(s, strip))
5679 s = s.substr(strip.size());
5684 static const int64_t values[] = {
5703 static const std::vector<int64_t> retval(values, values + 17);
5710 std::string stringifyNodeQueryTypeOfQueryTypeOneParameter(int64_t i,
const char *strip,
bool canonic) {
5712 if (retval.empty()) {
5713 retval =
"(NodeQuery::TypeOfQueryTypeOneParameter)" + boost::lexical_cast<std::string>(i);
5715 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5716 retval = retval.substr(strlen(strip));
5718 retval =
"NodeQuery::TypeOfQueryTypeOneParameter::" + retval;
5723 const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeOneParameter() {
5730 namespace stringify {
namespace NodeQuery {
5733 case 0L:
return "UnknownListElementTypeTwoParameters";
5734 case 1L:
return "FunctionDeclarationFromDefinition";
5735 case 2L:
return "ClassDeclarationFromName";
5736 case 3L:
return "ClassDeclarationsFromTypeName";
5737 case 4L:
return "PragmaDeclarationFromName";
5738 case 5L:
return "VariableDeclarationFromName";
5739 case 6L:
return "END_OF_NODE_TYPE_LIST_TWO_PARAMETERS";
5747 s =
"(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5748 if (boost::starts_with(s, strip))
5749 s = s.substr(strip.size());
5754 static const int64_t values[] = {
5763 static const std::vector<int64_t> retval(values, values + 7);
5770 std::string stringifyNodeQueryTypeOfQueryTypeTwoParameters(int64_t i,
const char *strip,
bool canonic) {
5772 if (retval.empty()) {
5773 retval =
"(NodeQuery::TypeOfQueryTypeTwoParameters)" + boost::lexical_cast<std::string>(i);
5775 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5776 retval = retval.substr(strlen(strip));
5778 retval =
"NodeQuery::TypeOfQueryTypeTwoParameters::" + retval;
5783 const std::vector<int64_t>& stringifyNodeQueryTypeOfQueryTypeTwoParameters() {
5793 case 0L:
return "MATCHMODE_SHALLOW";
5794 case 1L:
return "MATCHMODE_DEEP";
5795 case 2L:
return "MATCHMODE_SINGLE";
5803 s =
"(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
5804 if (boost::starts_with(s, strip))
5805 s = s.substr(strip.size());
5810 static const int64_t values[] = {
5815 static const std::vector<int64_t> retval(values, values + 3);
5822 std::string stringifyMatchStatusPatternMatchMode(int64_t i,
const char *strip,
bool canonic) {
5824 if (retval.empty()) {
5825 retval =
"(MatchStatus::PatternMatchMode)" + boost::lexical_cast<std::string>(i);
5827 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5828 retval = retval.substr(strlen(strip));
5830 retval =
"MatchStatus::PatternMatchMode::" + retval;
5835 const std::vector<int64_t>& stringifyMatchStatusPatternMatchMode() {
5845 case 0L:
return "NODECHECKMODE_TYPEID";
5846 case 1L:
return "NODECHECKMODE_VARIANT";
5854 s =
"(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
5855 if (boost::starts_with(s, strip))
5856 s = s.substr(strip.size());
5861 static const int64_t values[] = {
5865 static const std::vector<int64_t> retval(values, values + 2);
5872 std::string stringifyMatchStatusCheckNodeMode(int64_t i,
const char *strip,
bool canonic) {
5874 if (retval.empty()) {
5875 retval =
"(MatchStatus::CheckNodeMode)" + boost::lexical_cast<std::string>(i);
5877 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5878 retval = retval.substr(strlen(strip));
5880 retval =
"MatchStatus::CheckNodeMode::" + retval;
5885 const std::vector<int64_t>& stringifyMatchStatusCheckNodeMode() {
5895 case 258L:
return "ALTERNATION";
5896 case 259L:
return "NOT";
5897 case 260L:
return "AND";
5898 case 261L:
return "XOR";
5899 case 262L:
return "OR";
5900 case 263L:
return "NEQ";
5901 case 264L:
return "EQ";
5902 case 265L:
return "C_NEQ";
5903 case 266L:
return "C_EQ";
5904 case 267L:
return "WHERE";
5905 case 268L:
return "TRUE";
5906 case 269L:
return "FALSE";
5907 case 270L:
return "IDENT";
5908 case 271L:
return "VARIABLE";
5909 case 272L:
return "INTEGER";
5910 case 273L:
return "SQ_STRING";
5911 case 274L:
return "NULL_NODE";
5912 case 275L:
return "DOTDOT";
5920 s =
"(yytokentype)" + boost::lexical_cast<std::string>(i);
5921 if (boost::starts_with(s, strip))
5922 s = s.substr(strip.size());
5927 static const int64_t values[] = {
5947 static const std::vector<int64_t> retval(values, values + 18);
5954 std::string stringify_yytokentype(int64_t i,
const char *strip,
bool canonic) {
5956 if (retval.empty()) {
5957 retval =
"(yytokentype)" + boost::lexical_cast<std::string>(i);
5959 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
5960 retval = retval.substr(strlen(strip));
5962 retval =
"yytokentype::" + retval;
5967 const std::vector<int64_t>& stringify_yytokentype() {
5974 namespace stringify {
namespace MFB {
namespace Graph {
namespace API {
5977 case 0L:
return "e_link_kind_unknown";
5978 case 1L:
return "e_link_kind_defines";
5979 case 2L:
return "e_link_kind_extends";
5980 case 3L:
return "e_link_kind_specializes";
5981 case 4L:
return "e_link_kind_represents";
5982 case 5L:
return "e_link_kind_param";
5983 case 6L:
return "e_link_kind_arg";
5984 case 7L:
return "e_link_kind_type_base";
5985 case 8L:
return "e_link_kind_last";
5993 s =
"(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
5994 if (boost::starts_with(s, strip))
5995 s = s.substr(strip.size());
6000 static const int64_t values[] = {
6011 static const std::vector<int64_t> retval(values, values + 9);
6018 std::string stringifyMFB_GraphAPIlink_kind_e(int64_t i,
const char *strip,
bool canonic) {
6020 if (retval.empty()) {
6021 retval =
"(MFB::Graph::API::link_kind_e)" + boost::lexical_cast<std::string>(i);
6023 if (strip && !strncmp(strip, retval.c_str(), strlen(strip)))
6024 retval = retval.substr(strlen(strip));
6026 retval =
"MFB::Graph::API::link_kind_e::" + retval;
6031 const std::vector<int64_t>& stringifyMFB_GraphAPIlink_kind_e() {
6038 namespace stringify {
namespace CodeThorn {
namespace LabelProperty {
6041 case 1L:
return "LABEL_UNDEF";
6042 case 2L:
return "LABEL_OTHER";
6043 case 100L:
return "LABEL_FUNCTIONCALL";
6044 case 101L:
return "LABEL_FUNCTIONCALLRETURN";
6045 case 102L:
return "LABEL_FUNCTIONENTRY";
6046 case 103L:
return "LABEL_FUNCTIONEXIT";
6047 case 104L:
return "LABEL_BLOCKBEGIN";