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