mm/tools/decomp-permuter/stubs/pycparser/c_ast.py

#-----------------------------------------------------------------
# pycparser: c_ast.py
#
# AST Node classes.
#
# Eli Bendersky [https://eli.thegreenplace.net/]
# License: BSD
#-----------------------------------------------------------------


from typing import TextIO, Iterable, List, Any, Optional, Union as Union_
from .plyparser import Coord
import sys

class Node(object):
    coord: Optional[Coord]

    def __repr__(self) -> str: ...
    def __iter__(self) -> Iterable[Node]: ...
    def children(self) -> Iterable[Node]: ...
    def show(self, buf: TextIO=sys.stdout, offset: int=0, attrnames: bool=False, nodenames: bool=False, showcoord: bool=False) -> None: ...

Expression = Union_['ArrayRef', 'Assignment', 'BinaryOp', 'Cast',
        'CompoundLiteral', 'Constant', 'ExprList', 'FuncCall', 'ID',
        'TernaryOp', 'UnaryOp']
Statement = Union_[Expression, 'Break', 'Case', 'Compound', 'Continue',
        'Decl', 'Default', 'DoWhile', 'EmptyStatement', 'For', 'Goto', 'If',
        'Label', 'Return', 'Switch', 'Typedef', 'While', 'Pragma']
Type = Union_['PtrDecl', 'ArrayDecl', 'FuncDecl', 'TypeDecl']
InnerType = Union_['IdentifierType', 'Struct', 'Union', 'Enum']
ExternalDeclaration = Union_['FuncDef', 'Decl', 'Typedef', 'Pragma']
AnyNode = Union_[Statement, Type, InnerType, 'FuncDef', 'EllipsisParam',
        'Enumerator', 'EnumeratorList', 'FileAST', 'InitList',
        'NamedInitializer', 'ParamList', 'Typename']

class NodeVisitor:
    def visit(self, node: Node) -> None: ...
    def generic_visit(self, node: Node) -> None: ...
    def visit_ArrayDecl(self, node: ArrayDecl) -> None: ...
    def visit_ArrayRef(self, node: ArrayRef) -> None: ...
    def visit_Assignment(self, node: Assignment) -> None: ...
    def visit_BinaryOp(self, node: BinaryOp) -> None: ...
    def visit_Break(self, node: Break) -> None: ...
    def visit_Case(self, node: Case) -> None: ...
    def visit_Cast(self, node: Cast) -> None: ...
    def visit_Compound(self, node: Compound) -> None: ...
    def visit_CompoundLiteral(self, node: CompoundLiteral) -> None: ...
    def visit_Constant(self, node: Constant) -> None: ...
    def visit_Continue(self, node: Continue) -> None: ...
    def visit_Decl(self, node: Decl) -> None: ...
    def visit_DeclList(self, node: DeclList) -> None: ...
    def visit_Default(self, node: Default) -> None: ...
    def visit_DoWhile(self, node: DoWhile) -> None: ...
    def visit_EllipsisParam(self, node: EllipsisParam) -> None: ...
    def visit_EmptyStatement(self, node: EmptyStatement) -> None: ...
    def visit_Enum(self, node: Enum) -> None: ...
    def visit_Enumerator(self, node: Enumerator) -> None: ...
    def visit_EnumeratorList(self, node: EnumeratorList) -> None: ...
    def visit_ExprList(self, node: ExprList) -> None: ...
    def visit_FileAST(self, node: FileAST) -> None: ...
    def visit_For(self, node: For) -> None: ...
    def visit_FuncCall(self, node: FuncCall) -> None: ...
    def visit_FuncDecl(self, node: FuncDecl) -> None: ...
    def visit_FuncDef(self, node: FuncDef) -> None: ...
    def visit_Goto(self, node: Goto) -> None: ...
    def visit_ID(self, node: ID) -> None: ...
    def visit_IdentifierType(self, node: IdentifierType) -> None: ...
    def visit_If(self, node: If) -> None: ...
    def visit_InitList(self, node: InitList) -> None: ...
    def visit_Label(self, node: Label) -> None: ...
    def visit_NamedInitializer(self, node: NamedInitializer) -> None: ...
    def visit_ParamList(self, node: ParamList) -> None: ...
    def visit_PtrDecl(self, node: PtrDecl) -> None: ...
    def visit_Return(self, node: Return) -> None: ...
    def visit_Struct(self, node: Struct) -> None: ...
    def visit_StructRef(self, node: StructRef) -> None: ...
    def visit_Switch(self, node: Switch) -> None: ...
    def visit_TernaryOp(self, node: TernaryOp) -> None: ...
    def visit_TypeDecl(self, node: TypeDecl) -> None: ...
    def visit_Typedef(self, node: Typedef) -> None: ...
    def visit_Typename(self, node: Typename) -> None: ...
    def visit_UnaryOp(self, node: UnaryOp) -> None: ...
    def visit_Union(self, node: Union) -> None: ...
    def visit_While(self, node: While) -> None: ...
    def visit_Pragma(self, node: Pragma) -> None: ...

class ArrayDecl(Node):
    type: Type
    dim: Optional[Expression]
    dim_quals: List[str]
    def __init__(self, type: Type, dim: Optional[Node], dim_quals: List[str], coord: Optional[Coord]=None): ...

class ArrayRef(Node):
    name: Expression
    subscript: Expression
    def __init__(self, name: Node, subscript: Node, coord: Optional[Coord]=None): ...

class Assignment(Node):
    op: str
    lvalue: Expression
    rvalue: Expression
    def __init__(self, op: str, lvalue: Expression, rvalue: Expression, coord: Optional[Coord]=None): ...

class BinaryOp(Node):
    op: str
    left: Expression
    right: Expression
    def __init__(self, op: str, left: Node, right: Node, coord: Optional[Coord]=None): ...

class Break(Node):
    def __init__(self, coord: Optional[Coord]=None): ...

class Case(Node):
    expr: Expression
    stmts: List[Statement]
    def __init__(self, expr: Expression, stmts: List[Statement], coord: Optional[Coord]=None): ...

class Cast(Node):
    to_type: 'Typename'
    expr: Expression
    def __init__(self, to_type: 'Typename', expr: Expression, coord: Optional[Coord]=None): ...

class Compound(Node):
    block_items: Optional[List[Statement]]
    def __init__(self, block_items: Optional[List[Statement]], coord: Optional[Coord]=None): ...

class CompoundLiteral(Node):
    type: 'Typename'
    init: 'InitList'
    def __init__(self, type: 'Typename', init: 'InitList', coord: Optional[Coord]=None): ...

class Constant(Node):
    type: str
    value: str
    def __init__(self, type: str, value: str, coord: Optional[Coord]=None): ...

class Continue(Node):
    def __init__(self, coord: Optional[Coord]=None): ...

class Decl(Node):
    name: Optional[str]
    quals: List[str] # e.g. const
    storage: List[str] # e.g. register
    funcspec: List[str] # e.g. inline
    type: Type
    init: Optional[Union_[Expression, 'InitList']]
    bitsize: Optional[Expression]

    def __init__(self, name: Optional[str], quals: List[str], storage: List[str], funcspec: List[str], type: Type, init: Optional[Expression], bitsize: Optional[Expression], coord: Optional[Coord]=None): ...

class DeclList(Node):
    decls: List[Decl]
    def __init__(self, decls: List[Decl], coord: Optional[Coord]=None): ...

class Default(Node):
    stmts: List[Statement]
    def __init__(self, stmts: List[Statement], coord: Optional[Coord]=None): ...

class DoWhile(Node):
    cond: Expression
    stmt: Statement
    def __init__(self, cond: Expression, stmt: Statement, coord: Optional[Coord]=None): ...

class EllipsisParam(Node):
    def __init__(self, coord: Optional[Coord]=None): ...

class EmptyStatement(Node):
    def __init__(self, coord: Optional[Coord]=None): ...

class Enum(Node):
    name: Optional[str]
    values: 'EnumeratorList'
    def __init__(self, name: Optional[str], values: 'EnumeratorList', coord: Optional[Coord]=None): ...

class Enumerator(Node):
    name: str
    value: Optional[Expression]
    def __init__(self, name: str, value: Optional[Expression], coord: Optional[Coord]=None): ...

class EnumeratorList(Node):
    enumerators: List[Enumerator]
    def __init__(self, enumerators: List[Enumerator], coord: Optional[Coord]=None): ...

class ExprList(Node):
    exprs: List[Union_[Expression, Typename]] # typename only for offsetof
    def __init__(self, exprs: List[Union_[Expression, Typename]], coord: Optional[Coord]=None): ...

class FileAST(Node):
    ext: List[ExternalDeclaration]
    def __init__(self, ext: List[ExternalDeclaration], coord: Optional[Coord]=None): ...

class For(Node):
    init: Union_[None, Expression, DeclList]
    cond: Optional[Expression]
    next: Optional[Expression]
    stmt: Statement
    def __init__(self, init: Union_[None, Expression, DeclList], cond: Optional[Expression], next: Optional[Expression], stmt: Statement, coord: Optional[Coord]=None): ...

class FuncCall(Node):
    name: Expression
    args: Optional[ExprList]
    def __init__(self, name: Expression, args: Optional[ExprList], coord: Optional[Coord]=None): ...

class FuncDecl(Node):
    args: Optional[ParamList]
    type: Type # return type
    def __init__(self, args: Optional[ParamList], type: Type, coord: Optional[Coord]=None): ...

class FuncDef(Node):
    decl: Decl
    param_decls: Optional[List[Decl]]
    body: Compound
    def __init__(self, decl: Decl, param_decls: Optional[List[Decl]], body: Compound, coord: Optional[Coord]=None): ...

class Goto(Node):
    name: str
    def __init__(self, name: str, coord: Optional[Coord]=None): ...

class ID(Node):
    name: str
    def __init__(self, name: str, coord: Optional[Coord]=None): ...

class IdentifierType(Node):
    names: List[str] # e.g. ['long', 'int']
    def __init__(self, names: List[str], coord: Optional[Coord]=None): ...

class If(Node):
    cond: Expression
    iftrue: Statement
    iffalse: Optional[Statement]
    def __init__(self, cond: Expression, iftrue: Statement, iffalse: Optional[Statement], coord: Optional[Coord]=None): ...

class InitList(Node):
    exprs: List[Union_[Expression, 'NamedInitializer']]
    def __init__(self, exprs: List[Union_[Expression, 'NamedInitializer']], coord: Optional[Coord]=None): ...

class Label(Node):
    name: str
    stmt: Statement
    def __init__(self, name: str, stmt: Statement, coord: Optional[Coord]=None): ...

class NamedInitializer(Node):
    name: List[Expression] # [ID(x), Constant(4)] for {.x[4] = ...}
    expr: Expression
    def __init__(self, name: List[Expression], expr: Expression, coord: Optional[Coord]=None): ...

class ParamList(Node):
    params: List[Union_[Decl, ID, Typename, EllipsisParam]]
    def __init__(self, params: List[Union_[Decl, ID, Typename, EllipsisParam]], coord: Optional[Coord]=None): ...

class PtrDecl(Node):
    quals: List[str]
    type: Type
    def __init__(self, quals: List[str], type: Type, coord: Optional[Coord]=None): ...

class Return(Node):
    expr: Optional[Expression]
    def __init__(self, expr: Optional[Expression], coord: Optional[Coord]=None): ...

class Struct(Node):
    name: Optional[str]
    decls: Optional[List[Union_[Decl, Pragma]]]
    def __init__(self, name: Optional[str], decls: Optional[List[Union_[Decl, Pragma]]], coord: Optional[Coord]=None): ...

class StructRef(Node):
    name: Expression
    type: str
    field: ID
    def __init__(self, name: Expression, type: str, field: ID, coord: Optional[Coord]=None): ...

class Switch(Node):
    cond: Expression
    stmt: Statement
    def __init__(self, cond: Expression, stmt: Statement, coord: Optional[Coord]=None): ...

class TernaryOp(Node):
    cond: Expression
    iftrue: Expression
    iffalse: Expression
    def __init__(self, cond: Expression, iftrue: Expression, iffalse: Expression, coord: Optional[Coord]=None): ...

class TypeDecl(Node):
    declname: Optional[str]
    quals: List[str]
    type: InnerType
    def __init__(self, declname: Optional[str], quals: List[str], type: InnerType, coord: Optional[Coord]=None): ...

class Typedef(Node):
    name: str
    quals: List[str]
    storage: List[str]
    type: Type
    def __init__(self, name: str, quals: List[str], storage: List[str], type: Type, coord: Optional[Coord]=None): ...

class Typename(Node):
    name: None
    quals: List[str]
    type: Type
    def __init__(self, name: None, quals: List[str], type: Type, coord: Optional[Coord]=None): ...

class UnaryOp(Node):
    op: str
    expr: Union_[Expression, Typename]
    def __init__(self, op: str, expr: Union_[Expression, Typename], coord: Optional[Coord]=None): ...

class Union(Node):
    name: Optional[str]
    decls: Optional[List[Union_[Decl, Pragma]]]
    def __init__(self, name: Optional[str], decls: Optional[List[Union_[Decl, Pragma]]], coord: Optional[Coord]=None): ...

class While(Node):
    cond: Expression
    stmt: Statement
    def __init__(self, cond: Expression, stmt: Statement, coord: Optional[Coord]=None): ...

class Pragma(Node):
    string: str
    def __init__(self, string: str, coord: Optional[Coord]=None): ...