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