cpp.ast.TypeConverter Class Reference
Inheritance diagram for cpp.ast.TypeConverter:
Public Member Functions | |
| def | __init__ (self, namespace_stack) |
| def | ToType (self, tokens) |
| def | DeclarationToParts (self, parts, needs_name_removed) |
| def | ToParameters (self, tokens) |
| def | CreateReturnType (self, return_type_seq) |
| def | GetTemplateIndices (self, names) |
Public Attributes | |
| namespace_stack | |
Detailed Description
Constructor & Destructor Documentation
◆ __init__()
| def cpp.ast.TypeConverter.__init__ | ( | self, | |
| namespace_stack | |||
| ) |
Member Function Documentation
◆ CreateReturnType()
| def cpp.ast.TypeConverter.CreateReturnType | ( | self, | |
| return_type_seq | |||
| ) |
Definition at line 662 of file ast.py.
662 def CreateReturnType(self, return_type_seq):
663 if not return_type_seq:
664 return None
665 start = return_type_seq[0].start
666 end = return_type_seq[-1].end
667 _, name, templated_types, modifiers, default, other_tokens = \
668 self.DeclarationToParts(return_type_seq, False)
669 names = [n.name for n in other_tokens]
670 reference = '&' in names
671 pointer = '*' in names
672 array = '[' in names
673 return Type(start, end, name, templated_types, modifiers,
674 reference, pointer, array)
675
◆ DeclarationToParts()
| def cpp.ast.TypeConverter.DeclarationToParts | ( | self, | |
| parts, | |||
| needs_name_removed | |||
| ) |
Definition at line 534 of file ast.py.
534 def DeclarationToParts(self, parts, needs_name_removed):
535 name = None
536 default = []
537 if needs_name_removed:
538 # Handle default (initial) values properly.
539 for i, t in enumerate(parts):
540 if t.name == '=':
541 default = parts[i+1:]
542 name = parts[i-1].name
543 if name == ']' and parts[i-2].name == '[':
544 name = parts[i-3].name
545 i -= 1
546 parts = parts[:i-1]
547 break
548 else:
549 if parts[-1].token_type == tokenize.NAME:
550 name = parts.pop().name
551 else:
552 # TODO(nnorwitz): this is a hack that happens for code like
553 # Register(Foo<T>); where it thinks this is a function call
554 # but it's actually a declaration.
555 name = '???'
556 modifiers = []
557 type_name = []
558 other_tokens = []
559 templated_types = []
560 i = 0
561 end = len(parts)
562 while i < end:
563 p = parts[i]
564 if keywords.IsKeyword(p.name):
565 modifiers.append(p.name)
566 elif p.name == '<':
567 templated_tokens, new_end = self._GetTemplateEnd(parts, i+1)
568 templated_types = self.ToType(templated_tokens)
569 i = new_end - 1
570 # Don't add a spurious :: to data members being initialized.
571 next_index = i + 1
572 if next_index < end and parts[next_index].name == '::':
573 i += 1
574 elif p.name in ('[', ']', '='):
575 # These are handled elsewhere.
576 other_tokens.append(p)
577 elif p.name not in ('*', '&', '>'):
578 # Ensure that names have a space between them.
579 if (type_name and type_name[-1].token_type == tokenize.NAME and
580 p.token_type == tokenize.NAME):
581 type_name.append(tokenize.Token(tokenize.SYNTAX, ' ', 0, 0))
582 type_name.append(p)
583 else:
584 other_tokens.append(p)
585 i += 1
586 type_name = ''.join([t.name for t in type_name])
587 return name, type_name, templated_types, modifiers, default, other_tokens
588
◆ GetTemplateIndices()
| def cpp.ast.TypeConverter.GetTemplateIndices | ( | self, | |
| names | |||
| ) |
◆ ToParameters()
| def cpp.ast.TypeConverter.ToParameters | ( | self, | |
| tokens | |||
| ) |
Definition at line 589 of file ast.py.
589 def ToParameters(self, tokens):
590 if not tokens:
591 return []
592
593 result = []
594 name = type_name = ''
595 type_modifiers = []
596 pointer = reference = array = False
597 first_token = None
598 default = []
599
600 def AddParameter(end):
601 if default:
602 del default[0] # Remove flag.
603 parts = self.DeclarationToParts(type_modifiers, True)
604 (name, type_name, templated_types, modifiers,
605 unused_default, unused_other_tokens) = parts
606 parameter_type = Type(first_token.start, first_token.end,
607 type_name, templated_types, modifiers,
608 reference, pointer, array)
609 p = Parameter(first_token.start, end, name,
610 parameter_type, default)
611 result.append(p)
612
613 template_count = 0
614 brace_count = 0
615 for s in tokens:
616 if not first_token:
617 first_token = s
618
619 # Check for braces before templates, as we can have unmatched '<>'
620 # inside default arguments.
621 if s.name == '{':
622 brace_count += 1
623 elif s.name == '}':
624 brace_count -= 1
625 if brace_count > 0:
626 type_modifiers.append(s)
627 continue
628
629 if s.name == '<':
630 template_count += 1
631 elif s.name == '>':
632 template_count -= 1
633 if template_count > 0:
634 type_modifiers.append(s)
635 continue
636
637 if s.name == ',':
638 AddParameter(s.start)
639 name = type_name = ''
640 type_modifiers = []
641 pointer = reference = array = False
642 first_token = None
643 default = []
644 elif s.name == '*':
645 pointer = True
646 elif s.name == '&':
647 reference = True
648 elif s.name == '[':
649 array = True
650 elif s.name == ']':
651 pass # Just don't add to type_modifiers.
652 elif s.name == '=':
653 # Got a default value. Add any value (None) as a flag.
654 default.append(None)
655 elif default:
656 default.append(s)
657 else:
658 type_modifiers.append(s)
659 AddParameter(tokens[-1].end)
660 return result
661
◆ ToType()
| def cpp.ast.TypeConverter.ToType | ( | self, | |
| tokens | |||
| ) |
Convert [Token,...] to [Class(...), ] useful for base classes.
For example, code like class Foo : public Bar<x, y> { ... };
the "Bar<x, y>" portion gets converted to an AST.
Returns:
[Class(...), ...]
Definition at line 475 of file ast.py.
475 def ToType(self, tokens):
476 """Convert [Token,...] to [Class(...), ] useful for base classes.
477 For example, code like class Foo : public Bar<x, y> { ... };
478 the "Bar<x, y>" portion gets converted to an AST.
479
480 Returns:
481 [Class(...), ...]
482 """
483 result = []
484 name_tokens = []
485 reference = pointer = array = False
486
487 def AddType(templated_types):
488 # Partition tokens into name and modifier tokens.
489 names = []
490 modifiers = []
491 for t in name_tokens:
492 if keywords.IsKeyword(t.name):
493 modifiers.append(t.name)
494 else:
495 names.append(t.name)
496 name = ''.join(names)
497 if name_tokens:
498 result.append(Type(name_tokens[0].start, name_tokens[-1].end,
499 name, templated_types, modifiers,
500 reference, pointer, array))
501 del name_tokens[:]
502
503 i = 0
504 end = len(tokens)
505 while i < end:
506 token = tokens[i]
507 if token.name == '<':
508 new_tokens, new_end = self._GetTemplateEnd(tokens, i+1)
509 AddType(self.ToType(new_tokens))
510 # If there is a comma after the template, we need to consume
511 # that here otherwise it becomes part of the name.
512 i = new_end
513 reference = pointer = array = False
514 elif token.name == ',':
515 AddType([])
516 reference = pointer = array = False
517 elif token.name == '*':
518 pointer = True
519 elif token.name == '&':
520 reference = True
521 elif token.name == '[':
522 pointer = True
523 elif token.name == ']':
524 pass
525 else:
526 name_tokens.append(token)
527 i += 1
528
529 if name_tokens:
530 # No '<' in the tokens, just a simple name and no template.
531 AddType([])
532 return result
533
Member Data Documentation
◆ namespace_stack
The documentation for this class was generated from the following file:
- /media/home/debian/src/github/tesseract-ocr/tesseract/unittest/third_party/googletest/googlemock/scripts/generator/cpp/ast.py
