cpp.ast.AstBuilder Class Reference
Inheritance diagram for cpp.ast.AstBuilder:
Public Member Functions | |
| def | __init__ (self, token_stream, filename, in_class='', visibility=None, namespace_stack=[]) |
| def | HandleError (self, msg, token) |
| def | Generate (self) |
| def | GetScope (self) |
| def | GetName (self, seq=None) |
| def | GetMethod (self, modifiers, templated_types) |
| def | handle_bool (self) |
| def | handle_char (self) |
| def | handle_int (self) |
| def | handle_long (self) |
| def | handle_short (self) |
| def | handle_double (self) |
| def | handle_float (self) |
| def | handle_void (self) |
| def | handle_wchar_t (self) |
| def | handle_unsigned (self) |
| def | handle_signed (self) |
| def | handle_struct (self) |
| def | handle_union (self) |
| def | handle_enum (self) |
| def | handle_auto (self) |
| def | handle_register (self) |
| def | handle_const (self) |
| def | handle_inline (self) |
| def | handle_extern (self) |
| def | handle_static (self) |
| def | handle_virtual (self) |
| def | handle_volatile (self) |
| def | handle_mutable (self) |
| def | handle_public (self) |
| def | handle_protected (self) |
| def | handle_private (self) |
| def | handle_friend (self) |
| def | handle_static_cast (self) |
| def | handle_const_cast (self) |
| def | handle_dynamic_cast (self) |
| def | handle_reinterpret_cast (self) |
| def | handle_new (self) |
| def | handle_delete (self) |
| def | handle_typedef (self) |
| def | handle_typeid (self) |
| def | handle_typename (self) |
| def | handle_template (self) |
| def | handle_true (self) |
| def | handle_false (self) |
| def | handle_asm (self) |
| def | handle_class (self) |
| def | handle_namespace (self) |
| def | handle_using (self) |
| def | handle_explicit (self) |
| def | handle_this (self) |
| def | handle_operator (self) |
| def | handle_sizeof (self) |
| def | handle_case (self) |
| def | handle_switch (self) |
| def | handle_default (self) |
| def | handle_if (self) |
| def | handle_else (self) |
| def | handle_return (self) |
| def | handle_goto (self) |
| def | handle_try (self) |
| def | handle_catch (self) |
| def | handle_throw (self) |
| def | handle_while (self) |
| def | handle_do (self) |
| def | handle_for (self) |
| def | handle_break (self) |
| def | handle_continue (self) |
Public Attributes | |
| tokens | |
| filename | |
| token_queue | |
| namespace_stack | |
| in_class | |
| in_class_name_only | |
| visibility | |
| in_function | |
| current_token | |
| converter | |
Detailed Description
Constructor & Destructor Documentation
◆ __init__()
| def cpp.ast.AstBuilder.__init__ | ( | self, | |
| token_stream, | |||
| filename, | |||
in_class = '', |
|||
visibility = None, |
|||
namespace_stack = [] |
|||
| ) |
Definition at line 687 of file ast.py.
688 namespace_stack=[]):
689 self.tokens = token_stream
690 self.filename = filename
691 # TODO(nnorwitz): use a better data structure (deque) for the queue.
692 # Switching directions of the "queue" improved perf by about 25%.
693 # Using a deque should be even better since we access from both sides.
694 self.token_queue = []
695 self.namespace_stack = namespace_stack[:]
696 self.in_class = in_class
697 if in_class is None:
698 self.in_class_name_only = None
699 else:
700 self.in_class_name_only = in_class.split('::')[-1]
701 self.visibility = visibility
702 self.in_function = False
703 self.current_token = None
704 # Keep the state whether we are currently handling a typedef or not.
705 self._handling_typedef = False
706
707 self.converter = TypeConverter(self.namespace_stack)
708
Member Function Documentation
◆ Generate()
| def cpp.ast.AstBuilder.Generate | ( | self | ) |
Definition at line 714 of file ast.py.
714 def Generate(self):
715 while 1:
716 token = self._GetNextToken()
717 if not token:
718 break
719
720 # Get the next token.
721 self.current_token = token
722
723 # Dispatch on the next token type.
724 if token.token_type == _INTERNAL_TOKEN:
725 if token.name == _NAMESPACE_POP:
726 self.namespace_stack.pop()
727 continue
728
729 try:
730 result = self._GenerateOne(token)
731 if result is not None:
732 yield result
733 except:
734 self.HandleError('exception', token)
735 raise
736
◆ GetMethod()
| def cpp.ast.AstBuilder.GetMethod | ( | self, | |
| modifiers, | |||
| templated_types | |||
| ) |
◆ GetName()
| def cpp.ast.AstBuilder.GetName | ( | self, | |
seq = None |
|||
| ) |
Returns ([tokens], next_token_info).
Definition at line 968 of file ast.py.
968 def GetName(self, seq=None):
969 """Returns ([tokens], next_token_info)."""
970 GetNextToken = self._GetNextToken
971 if seq is not None:
972 it = iter(seq)
974 next_token = GetNextToken()
975 tokens = []
976 last_token_was_name = False
977 while (next_token.token_type == tokenize.NAME or
978 (next_token.token_type == tokenize.SYNTAX and
979 next_token.name in ('::', '<'))):
980 # Two NAMEs in a row means the identifier should terminate.
981 # It's probably some sort of variable declaration.
982 if last_token_was_name and next_token.token_type == tokenize.NAME:
983 break
984 last_token_was_name = next_token.token_type == tokenize.NAME
985 tokens.append(next_token)
986 # Handle templated names.
987 if next_token.name == '<':
988 tokens.extend(self._GetMatchingChar('<', '>', GetNextToken))
989 last_token_was_name = True
990 next_token = GetNextToken()
991 return tokens, next_token
992
◆ GetScope()
| def cpp.ast.AstBuilder.GetScope | ( | self | ) |
◆ handle_asm()
| def cpp.ast.AstBuilder.handle_asm | ( | self | ) |
◆ handle_auto()
| def cpp.ast.AstBuilder.handle_auto | ( | self | ) |
◆ handle_bool()
| def cpp.ast.AstBuilder.handle_bool | ( | self | ) |
◆ handle_break()
| def cpp.ast.AstBuilder.handle_break | ( | self | ) |
◆ handle_case()
| def cpp.ast.AstBuilder.handle_case | ( | self | ) |
◆ handle_catch()
| def cpp.ast.AstBuilder.handle_catch | ( | self | ) |
◆ handle_char()
| def cpp.ast.AstBuilder.handle_char | ( | self | ) |
◆ handle_class()
| def cpp.ast.AstBuilder.handle_class | ( | self | ) |
◆ handle_const()
| def cpp.ast.AstBuilder.handle_const | ( | self | ) |
◆ handle_const_cast()
| def cpp.ast.AstBuilder.handle_const_cast | ( | self | ) |
◆ handle_continue()
| def cpp.ast.AstBuilder.handle_continue | ( | self | ) |
◆ handle_default()
| def cpp.ast.AstBuilder.handle_default | ( | self | ) |
◆ handle_delete()
| def cpp.ast.AstBuilder.handle_delete | ( | self | ) |
◆ handle_do()
| def cpp.ast.AstBuilder.handle_do | ( | self | ) |
◆ handle_double()
| def cpp.ast.AstBuilder.handle_double | ( | self | ) |
◆ handle_dynamic_cast()
| def cpp.ast.AstBuilder.handle_dynamic_cast | ( | self | ) |
◆ handle_else()
| def cpp.ast.AstBuilder.handle_else | ( | self | ) |
◆ handle_enum()
| def cpp.ast.AstBuilder.handle_enum | ( | self | ) |
◆ handle_explicit()
| def cpp.ast.AstBuilder.handle_explicit | ( | self | ) |
◆ handle_extern()
| def cpp.ast.AstBuilder.handle_extern | ( | self | ) |
◆ handle_false()
| def cpp.ast.AstBuilder.handle_false | ( | self | ) |
◆ handle_float()
| def cpp.ast.AstBuilder.handle_float | ( | self | ) |
◆ handle_for()
| def cpp.ast.AstBuilder.handle_for | ( | self | ) |
◆ handle_friend()
| def cpp.ast.AstBuilder.handle_friend | ( | self | ) |
◆ handle_goto()
| def cpp.ast.AstBuilder.handle_goto | ( | self | ) |
◆ handle_if()
| def cpp.ast.AstBuilder.handle_if | ( | self | ) |
◆ handle_inline()
| def cpp.ast.AstBuilder.handle_inline | ( | self | ) |
◆ handle_int()
| def cpp.ast.AstBuilder.handle_int | ( | self | ) |
◆ handle_long()
| def cpp.ast.AstBuilder.handle_long | ( | self | ) |
◆ handle_mutable()
| def cpp.ast.AstBuilder.handle_mutable | ( | self | ) |
◆ handle_namespace()
| def cpp.ast.AstBuilder.handle_namespace | ( | self | ) |
Definition at line 1602 of file ast.py.
1602 def handle_namespace(self):
1603 # Support anonymous namespaces.
1604 name = None
1605 name_tokens, token = self.GetName()
1606 if name_tokens:
1607 name = ''.join([t.name for t in name_tokens])
1608 self.namespace_stack.append(name)
1609 assert token.token_type == tokenize.SYNTAX, token
1610 # Create an internal token that denotes when the namespace is complete.
1611 internal_token = tokenize.Token(_INTERNAL_TOKEN, _NAMESPACE_POP,
1612 None, None)
1613 internal_token.whence = token.whence
1614 if token.name == '=':
1615 # TODO(nnorwitz): handle aliasing namespaces.
1616 name, next_token = self.GetName()
1617 assert next_token.name == ';', next_token
1618 self._AddBackToken(internal_token)
1619 else:
1620 assert token.name == '{', token
1621 tokens = list(self.GetScope())
1622 # Replace the trailing } with the internal namespace pop token.
1623 tokens[-1] = internal_token
1624 # Handle namespace with nothing in it.
1625 self._AddBackTokens(tokens)
1626 return None
1627
◆ handle_new()
| def cpp.ast.AstBuilder.handle_new | ( | self | ) |
◆ handle_operator()
| def cpp.ast.AstBuilder.handle_operator | ( | self | ) |
◆ handle_private()
| def cpp.ast.AstBuilder.handle_private | ( | self | ) |
◆ handle_protected()
| def cpp.ast.AstBuilder.handle_protected | ( | self | ) |
◆ handle_public()
| def cpp.ast.AstBuilder.handle_public | ( | self | ) |
◆ handle_register()
| def cpp.ast.AstBuilder.handle_register | ( | self | ) |
◆ handle_reinterpret_cast()
| def cpp.ast.AstBuilder.handle_reinterpret_cast | ( | self | ) |
◆ handle_return()
| def cpp.ast.AstBuilder.handle_return | ( | self | ) |
◆ handle_short()
| def cpp.ast.AstBuilder.handle_short | ( | self | ) |
◆ handle_signed()
| def cpp.ast.AstBuilder.handle_signed | ( | self | ) |
◆ handle_sizeof()
| def cpp.ast.AstBuilder.handle_sizeof | ( | self | ) |
◆ handle_static()
| def cpp.ast.AstBuilder.handle_static | ( | self | ) |
◆ handle_static_cast()
| def cpp.ast.AstBuilder.handle_static_cast | ( | self | ) |
◆ handle_struct()
| def cpp.ast.AstBuilder.handle_struct | ( | self | ) |
Definition at line 1267 of file ast.py.
1267 def handle_struct(self):
1268 # Special case the handling typedef/aliasing of structs here.
1269 # It would be a pain to handle in the class code.
1270 name_tokens, var_token = self.GetName()
1271 if name_tokens:
1272 next_token = self._GetNextToken()
1273 is_syntax = (var_token.token_type == tokenize.SYNTAX and
1274 var_token.name[0] in '*&')
1275 is_variable = (var_token.token_type == tokenize.NAME and
1276 next_token.name == ';')
1277 variable = var_token
1278 if is_syntax and not is_variable:
1279 variable = next_token
1280 temp = self._GetNextToken()
1281 if temp.token_type == tokenize.SYNTAX and temp.name == '(':
1282 # Handle methods declared to return a struct.
1283 t0 = name_tokens[0]
1284 struct = tokenize.Token(tokenize.NAME, 'struct',
1285 t0.start-7, t0.start-2)
1286 type_and_name = [struct]
1287 type_and_name.extend(name_tokens)
1288 type_and_name.extend((var_token, next_token))
1289 return self._GetMethod(type_and_name, 0, None, False)
1290 assert temp.name == ';', (temp, name_tokens, var_token)
1291 if is_syntax or (is_variable and not self._handling_typedef):
1292 modifiers = ['struct']
1293 type_name = ''.join([t.name for t in name_tokens])
1294 position = name_tokens[0]
1295 return self._CreateVariable(position, variable.name, type_name,
1296 modifiers, var_token.name, None)
1297 name_tokens.extend((var_token, next_token))
1298 self._AddBackTokens(name_tokens)
1299 else:
1300 self._AddBackToken(var_token)
1301 return self._GetClass(Struct, VISIBILITY_PUBLIC, None)
1302
◆ handle_switch()
| def cpp.ast.AstBuilder.handle_switch | ( | self | ) |
◆ handle_template()
| def cpp.ast.AstBuilder.handle_template | ( | self | ) |
Definition at line 1463 of file ast.py.
1463 def handle_template(self):
1464 token = self._GetNextToken()
1465 assert token.token_type == tokenize.SYNTAX, token
1466 assert token.name == '<', token
1467 templated_types = self._GetTemplatedTypes()
1468 # TODO(nnorwitz): for now, just ignore the template params.
1469 token = self._GetNextToken()
1470 if token.token_type == tokenize.NAME:
1471 if token.name == 'class':
1472 return self._GetClass(Class, VISIBILITY_PRIVATE, templated_types)
1473 elif token.name == 'struct':
1474 return self._GetClass(Struct, VISIBILITY_PUBLIC, templated_types)
1475 elif token.name == 'friend':
1476 return self.handle_friend()
1477 self._AddBackToken(token)
1478 tokens, last = self._GetVarTokensUpTo(tokenize.SYNTAX, '(', ';')
1479 tokens.append(last)
1480 self._AddBackTokens(tokens)
1481 if last.name == '(':
1482 return self.GetMethod(FUNCTION_NONE, templated_types)
1483 # Must be a variable definition.
1484 return None
1485
◆ handle_this()
| def cpp.ast.AstBuilder.handle_this | ( | self | ) |
◆ handle_throw()
| def cpp.ast.AstBuilder.handle_throw | ( | self | ) |
◆ handle_true()
| def cpp.ast.AstBuilder.handle_true | ( | self | ) |
◆ handle_try()
| def cpp.ast.AstBuilder.handle_try | ( | self | ) |
◆ handle_typedef()
| def cpp.ast.AstBuilder.handle_typedef | ( | self | ) |
Definition at line 1390 of file ast.py.
1390 def handle_typedef(self):
1391 token = self._GetNextToken()
1392 if (token.token_type == tokenize.NAME and
1393 keywords.IsKeyword(token.name)):
1394 # Token must be struct/enum/union/class.
1395 method = getattr(self, 'handle_' + token.name)
1396 self._handling_typedef = True
1397 tokens = [method()]
1398 self._handling_typedef = False
1399 else:
1400 tokens = [token]
1401
1402 # Get the remainder of the typedef up to the semi-colon.
1403 tokens.extend(self._GetTokensUpTo(tokenize.SYNTAX, ';'))
1404
1405 # TODO(nnorwitz): clean all this up.
1406 assert tokens
1407 name = tokens.pop()
1408 indices = name
1409 if tokens:
1410 indices = tokens[0]
1411 if not indices:
1412 indices = token
1413 if name.name == ')':
1414 # HACK(nnorwitz): Handle pointers to functions "properly".
1415 if (len(tokens) >= 4 and
1416 tokens[1].name == '(' and tokens[2].name == '*'):
1417 tokens.append(name)
1418 name = tokens[3]
1419 elif name.name == ']':
1420 # HACK(nnorwitz): Handle arrays properly.
1421 if len(tokens) >= 2:
1422 tokens.append(name)
1423 name = tokens[1]
1424 new_type = tokens
1425 if tokens and isinstance(tokens[0], tokenize.Token):
1426 new_type = self.converter.ToType(tokens)[0]
1427 return Typedef(indices.start, indices.end, name.name,
1428 new_type, self.namespace_stack)
1429
◆ handle_typeid()
| def cpp.ast.AstBuilder.handle_typeid | ( | self | ) |
◆ handle_typename()
| def cpp.ast.AstBuilder.handle_typename | ( | self | ) |
◆ handle_union()
| def cpp.ast.AstBuilder.handle_union | ( | self | ) |
◆ handle_unsigned()
| def cpp.ast.AstBuilder.handle_unsigned | ( | self | ) |
◆ handle_using()
| def cpp.ast.AstBuilder.handle_using | ( | self | ) |
◆ handle_virtual()
| def cpp.ast.AstBuilder.handle_virtual | ( | self | ) |
Definition at line 1329 of file ast.py.
1329 def handle_virtual(self):
1330 # What follows must be a method.
1331 token = token2 = self._GetNextToken()
1332 if token.name == 'inline':
1333 # HACK(nnorwitz): handle inline dtors by ignoring 'inline'.
1334 token2 = self._GetNextToken()
1335 if token2.token_type == tokenize.SYNTAX and token2.name == '~':
1336 return self.GetMethod(FUNCTION_VIRTUAL + FUNCTION_DTOR, None)
1337 assert token.token_type == tokenize.NAME or token.name == '::', token
1338 return_type_and_name, _ = self._GetVarTokensUpToIgnoringTemplates(
1339 tokenize.SYNTAX, '(') # )
1340 return_type_and_name.insert(0, token)
1341 if token2 is not token:
1342 return_type_and_name.insert(1, token2)
1343 return self._GetMethod(return_type_and_name, FUNCTION_VIRTUAL,
1344 None, False)
1345
◆ handle_void()
| def cpp.ast.AstBuilder.handle_void | ( | self | ) |
◆ handle_volatile()
| def cpp.ast.AstBuilder.handle_volatile | ( | self | ) |
◆ handle_wchar_t()
| def cpp.ast.AstBuilder.handle_wchar_t | ( | self | ) |
◆ handle_while()
| def cpp.ast.AstBuilder.handle_while | ( | self | ) |
◆ HandleError()
| def cpp.ast.AstBuilder.HandleError | ( | self, | |
| msg, | |||
| token | |||
| ) |
Member Data Documentation
◆ converter
◆ current_token
◆ filename
◆ in_class
◆ in_class_name_only
◆ in_function
◆ namespace_stack
◆ token_queue
◆ tokens
◆ visibility
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
