Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
P
Pyston
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
Analytics
Analytics
Repository
Value Stream
Wiki
Wiki
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Commits
Issue Boards
Open sidebar
Boxiang Sun
Pyston
Commits
42a07f21
Commit
42a07f21
authored
Sep 02, 2016
by
Kevin Modzelewski
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Copy ast->bst
And remove some extraneous things from bst
parent
362a327d
Changes
3
Show whitespace changes
Inline
Side-by-side
Showing
3 changed files
with
3499 additions
and
0 deletions
+3499
-0
src/CMakeLists.txt
src/CMakeLists.txt
+1
-0
src/core/bst.cpp
src/core/bst.cpp
+2050
-0
src/core/bst.h
src/core/bst.h
+1448
-0
No files found.
src/CMakeLists.txt
View file @
42a07f21
...
@@ -65,6 +65,7 @@ add_library(PYSTON_OBJECTS OBJECT ${OPTIONAL_SRCS}
...
@@ -65,6 +65,7 @@ add_library(PYSTON_OBJECTS OBJECT ${OPTIONAL_SRCS}
codegen/type_recording.cpp
codegen/type_recording.cpp
codegen/unwinding.cpp
codegen/unwinding.cpp
core/ast.cpp
core/ast.cpp
core/bst.cpp
core/cfg.cpp
core/cfg.cpp
core/options.cpp
core/options.cpp
core/stats.cpp
core/stats.cpp
...
...
src/core/bst.cpp
0 → 100644
View file @
42a07f21
// Copyright (c) 2014-2016 Dropbox, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "core/bst.h"
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stdint.h>
#include "Python.h"
#include "core/cfg.h"
#include "runtime/types.h"
namespace
pyston
{
#ifdef DEBUG_LINE_NUMBERS
int
BST
::
next_lineno
=
100000
;
BST
::
BST
(
BST_TYPE
::
BST_TYPE
type
)
:
type
(
type
),
lineno
(
++
next_lineno
)
{
// if (lineno == 100644)
// raise(SIGTRAP);
}
#endif
template
<
class
T
>
static
void
visitVector
(
const
std
::
vector
<
T
*>&
vec
,
BSTVisitor
*
v
)
{
for
(
int
i
=
0
;
i
<
vec
.
size
();
i
++
)
{
vec
[
i
]
->
accept
(
v
);
}
}
void
BST_alias
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_alias
(
this
);
if
(
skip
)
return
;
}
void
BST_arguments
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_arguments
(
this
);
if
(
skip
)
return
;
visitVector
(
defaults
,
v
);
visitVector
(
args
,
v
);
if
(
kwarg
)
kwarg
->
accept
(
v
);
if
(
vararg
)
vararg
->
accept
(
v
);
}
void
BST_Assert
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_assert
(
this
);
if
(
skip
)
return
;
test
->
accept
(
v
);
if
(
msg
)
msg
->
accept
(
v
);
}
void
BST_Assert
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_assert
(
this
);
}
void
BST_Assign
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_assign
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
for
(
int
i
=
0
;
i
<
targets
.
size
();
i
++
)
{
// Targets are assigned to left-to-right, so this is valid:
// x = x.a = object()
// but this is not:
// x.a = x = object()
targets
[
i
]
->
accept
(
v
);
}
}
void
BST_Assign
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_assign
(
this
);
}
void
BST_AugAssign
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_augassign
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
target
->
accept
(
v
);
}
void
BST_AugAssign
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_augassign
(
this
);
}
void
BST_AugBinOp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_augbinop
(
this
);
if
(
skip
)
return
;
left
->
accept
(
v
);
right
->
accept
(
v
);
}
void
*
BST_AugBinOp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_augbinop
(
this
);
}
void
BST_Attribute
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_attribute
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
}
void
*
BST_Attribute
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_attribute
(
this
);
}
void
BST_BinOp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_binop
(
this
);
if
(
skip
)
return
;
left
->
accept
(
v
);
right
->
accept
(
v
);
}
void
*
BST_BinOp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_binop
(
this
);
}
void
BST_BoolOp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_boolop
(
this
);
if
(
skip
)
return
;
visitVector
(
values
,
v
);
}
void
*
BST_BoolOp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_boolop
(
this
);
}
void
BST_Break
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_break
(
this
);
if
(
skip
)
return
;
}
void
BST_Break
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_break
(
this
);
}
void
BST_Call
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_call
(
this
);
if
(
skip
)
return
;
func
->
accept
(
v
);
visitVector
(
args
,
v
);
visitVector
(
keywords
,
v
);
if
(
starargs
)
starargs
->
accept
(
v
);
if
(
kwargs
)
kwargs
->
accept
(
v
);
}
void
*
BST_Call
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_call
(
this
);
}
void
BST_Compare
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_compare
(
this
);
if
(
skip
)
return
;
left
->
accept
(
v
);
visitVector
(
comparators
,
v
);
}
void
*
BST_Compare
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_compare
(
this
);
}
void
BST_comprehension
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_comprehension
(
this
);
if
(
skip
)
return
;
target
->
accept
(
v
);
iter
->
accept
(
v
);
for
(
auto
if_
:
ifs
)
{
if_
->
accept
(
v
);
}
}
void
BST_ClassDef
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_classdef
(
this
);
if
(
skip
)
return
;
visitVector
(
this
->
bases
,
v
);
visitVector
(
this
->
decorator_list
,
v
);
visitVector
(
this
->
body
,
v
);
}
void
BST_ClassDef
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_classdef
(
this
);
}
void
BST_Continue
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_continue
(
this
);
if
(
skip
)
return
;
}
void
BST_Continue
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_continue
(
this
);
}
void
BST_Delete
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_delete
(
this
);
if
(
skip
)
return
;
visitVector
(
this
->
targets
,
v
);
}
void
BST_Delete
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_delete
(
this
);
}
void
BST_Dict
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_dict
(
this
);
if
(
skip
)
return
;
for
(
int
i
=
0
;
i
<
keys
.
size
();
i
++
)
{
keys
[
i
]
->
accept
(
v
);
values
[
i
]
->
accept
(
v
);
}
}
void
*
BST_Dict
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_dict
(
this
);
}
void
BST_DictComp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_dictcomp
(
this
);
if
(
skip
)
return
;
for
(
auto
c
:
generators
)
{
c
->
accept
(
v
);
}
value
->
accept
(
v
);
key
->
accept
(
v
);
}
void
*
BST_DictComp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_dictcomp
(
this
);
}
void
BST_Ellipsis
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_ellipsis
(
this
);
if
(
skip
)
return
;
}
void
*
BST_Ellipsis
::
accept_slice
(
SliceVisitor
*
v
)
{
return
v
->
visit_ellipsis
(
this
);
}
void
BST_ExceptHandler
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_excepthandler
(
this
);
if
(
skip
)
return
;
if
(
type
)
type
->
accept
(
v
);
if
(
name
)
name
->
accept
(
v
);
visitVector
(
body
,
v
);
}
void
BST_Exec
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_exec
(
this
);
if
(
skip
)
return
;
if
(
body
)
body
->
accept
(
v
);
if
(
globals
)
globals
->
accept
(
v
);
if
(
locals
)
locals
->
accept
(
v
);
}
void
BST_Exec
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_exec
(
this
);
}
void
BST_Expr
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_expr
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
}
void
BST_Expr
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_expr
(
this
);
}
void
BST_ExtSlice
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_extslice
(
this
);
if
(
skip
)
return
;
visitVector
(
dims
,
v
);
}
void
*
BST_ExtSlice
::
accept_slice
(
SliceVisitor
*
v
)
{
return
v
->
visit_extslice
(
this
);
}
void
BST_For
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_for
(
this
);
if
(
skip
)
return
;
iter
->
accept
(
v
);
target
->
accept
(
v
);
visitVector
(
body
,
v
);
visitVector
(
orelse
,
v
);
}
void
BST_For
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_for
(
this
);
}
void
BST_FunctionDef
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_functiondef
(
this
);
if
(
skip
)
return
;
visitVector
(
decorator_list
,
v
);
args
->
accept
(
v
);
visitVector
(
body
,
v
);
}
void
BST_FunctionDef
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_functiondef
(
this
);
}
void
BST_GeneratorExp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_generatorexp
(
this
);
if
(
skip
)
return
;
for
(
auto
c
:
generators
)
{
c
->
accept
(
v
);
}
elt
->
accept
(
v
);
}
void
*
BST_GeneratorExp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_generatorexp
(
this
);
}
void
BST_Global
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_global
(
this
);
if
(
skip
)
return
;
}
void
BST_Global
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_global
(
this
);
}
void
BST_If
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_if
(
this
);
if
(
skip
)
return
;
test
->
accept
(
v
);
visitVector
(
body
,
v
);
visitVector
(
orelse
,
v
);
}
void
BST_If
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_if
(
this
);
}
void
BST_IfExp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_ifexp
(
this
);
if
(
skip
)
return
;
this
->
test
->
accept
(
v
);
this
->
body
->
accept
(
v
);
this
->
orelse
->
accept
(
v
);
}
void
*
BST_IfExp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_ifexp
(
this
);
}
void
BST_Import
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_import
(
this
);
if
(
skip
)
return
;
visitVector
(
names
,
v
);
}
void
BST_Import
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_import
(
this
);
}
void
BST_ImportFrom
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_importfrom
(
this
);
if
(
skip
)
return
;
visitVector
(
names
,
v
);
}
void
BST_ImportFrom
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_importfrom
(
this
);
}
void
BST_Index
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_index
(
this
);
if
(
skip
)
return
;
this
->
value
->
accept
(
v
);
}
void
*
BST_Index
::
accept_slice
(
SliceVisitor
*
v
)
{
return
v
->
visit_index
(
this
);
}
void
BST_Invoke
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_invoke
(
this
);
if
(
skip
)
return
;
this
->
stmt
->
accept
(
v
);
}
void
BST_Invoke
::
accept_stmt
(
StmtVisitor
*
v
)
{
return
v
->
visit_invoke
(
this
);
}
void
BST_keyword
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_keyword
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
}
void
BST_Lambda
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_lambda
(
this
);
if
(
skip
)
return
;
args
->
accept
(
v
);
body
->
accept
(
v
);
}
void
*
BST_Lambda
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_lambda
(
this
);
}
void
BST_LangPrimitive
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_langprimitive
(
this
);
if
(
skip
)
return
;
visitVector
(
args
,
v
);
}
void
*
BST_LangPrimitive
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_langprimitive
(
this
);
}
void
BST_List
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_list
(
this
);
if
(
skip
)
return
;
visitVector
(
elts
,
v
);
}
void
*
BST_List
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_list
(
this
);
}
void
BST_ListComp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_listcomp
(
this
);
if
(
skip
)
return
;
for
(
auto
c
:
generators
)
{
c
->
accept
(
v
);
}
elt
->
accept
(
v
);
}
void
*
BST_ListComp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_listcomp
(
this
);
}
void
BST_Module
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_module
(
this
);
if
(
skip
)
return
;
visitVector
(
body
,
v
);
}
void
BST_Expression
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_expression
(
this
);
if
(
skip
)
return
;
body
->
accept
(
v
);
}
void
BST_Suite
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_suite
(
this
);
if
(
skip
)
return
;
visitVector
(
body
,
v
);
}
void
BST_Name
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_name
(
this
);
}
void
*
BST_Name
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_name
(
this
);
}
void
BST_Num
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_num
(
this
);
}
void
*
BST_Num
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_num
(
this
);
}
void
BST_Pass
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_pass
(
this
);
}
void
BST_Pass
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_pass
(
this
);
}
void
BST_Print
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_print
(
this
);
if
(
skip
)
return
;
if
(
dest
)
dest
->
accept
(
v
);
visitVector
(
values
,
v
);
}
void
BST_Print
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_print
(
this
);
}
void
BST_Raise
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_raise
(
this
);
if
(
skip
)
return
;
if
(
arg0
)
arg0
->
accept
(
v
);
if
(
arg1
)
arg1
->
accept
(
v
);
if
(
arg2
)
arg2
->
accept
(
v
);
}
void
BST_Raise
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_raise
(
this
);
}
void
BST_Repr
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_repr
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
}
void
*
BST_Repr
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_repr
(
this
);
}
void
BST_Return
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_return
(
this
);
if
(
skip
)
return
;
if
(
value
)
value
->
accept
(
v
);
}
void
BST_Return
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_return
(
this
);
}
void
BST_Set
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_set
(
this
);
if
(
skip
)
return
;
visitVector
(
elts
,
v
);
}
void
*
BST_Set
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_set
(
this
);
}
void
BST_SetComp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_setcomp
(
this
);
if
(
skip
)
return
;
for
(
auto
c
:
generators
)
{
c
->
accept
(
v
);
}
elt
->
accept
(
v
);
}
void
*
BST_SetComp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_setcomp
(
this
);
}
void
BST_Slice
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_slice
(
this
);
if
(
skip
)
return
;
if
(
lower
)
lower
->
accept
(
v
);
if
(
upper
)
upper
->
accept
(
v
);
if
(
step
)
step
->
accept
(
v
);
}
void
*
BST_Slice
::
accept_slice
(
SliceVisitor
*
v
)
{
return
v
->
visit_slice
(
this
);
}
void
BST_Str
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_str
(
this
);
if
(
skip
)
return
;
}
void
*
BST_Str
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_str
(
this
);
}
void
BST_Subscript
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_subscript
(
this
);
if
(
skip
)
return
;
this
->
value
->
accept
(
v
);
this
->
slice
->
accept
(
v
);
}
void
*
BST_Subscript
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_subscript
(
this
);
}
void
BST_TryExcept
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_tryexcept
(
this
);
if
(
skip
)
return
;
visitVector
(
body
,
v
);
visitVector
(
orelse
,
v
);
visitVector
(
handlers
,
v
);
}
void
BST_TryExcept
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_tryexcept
(
this
);
}
void
BST_TryFinally
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_tryfinally
(
this
);
if
(
skip
)
return
;
visitVector
(
body
,
v
);
visitVector
(
finalbody
,
v
);
}
void
BST_TryFinally
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_tryfinally
(
this
);
}
void
BST_Tuple
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_tuple
(
this
);
if
(
skip
)
return
;
visitVector
(
elts
,
v
);
}
void
*
BST_Tuple
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_tuple
(
this
);
}
void
BST_UnaryOp
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_unaryop
(
this
);
if
(
skip
)
return
;
operand
->
accept
(
v
);
}
void
*
BST_UnaryOp
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_unaryop
(
this
);
}
void
BST_While
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_while
(
this
);
if
(
skip
)
return
;
test
->
accept
(
v
);
visitVector
(
body
,
v
);
visitVector
(
orelse
,
v
);
}
void
BST_While
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_while
(
this
);
}
void
BST_With
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_with
(
this
);
if
(
skip
)
return
;
context_expr
->
accept
(
v
);
if
(
optional_vars
)
optional_vars
->
accept
(
v
);
visitVector
(
body
,
v
);
}
void
BST_With
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_with
(
this
);
}
void
BST_Yield
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_yield
(
this
);
if
(
skip
)
return
;
if
(
value
)
value
->
accept
(
v
);
}
void
*
BST_Yield
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_yield
(
this
);
}
void
BST_Branch
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_branch
(
this
);
if
(
skip
)
return
;
test
->
accept
(
v
);
}
void
BST_Branch
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_branch
(
this
);
}
void
BST_Jump
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_jump
(
this
);
if
(
skip
)
return
;
}
void
BST_Jump
::
accept_stmt
(
StmtVisitor
*
v
)
{
v
->
visit_jump
(
this
);
}
void
BST_ClsAttribute
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_clsattribute
(
this
);
if
(
skip
)
return
;
value
->
accept
(
v
);
}
void
*
BST_ClsAttribute
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_clsattribute
(
this
);
}
void
BST_MakeFunction
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_makefunction
(
this
);
if
(
skip
)
return
;
function_def
->
accept
(
v
);
}
void
*
BST_MakeFunction
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_makefunction
(
this
);
}
void
BST_MakeClass
::
accept
(
BSTVisitor
*
v
)
{
bool
skip
=
v
->
visit_makeclass
(
this
);
if
(
skip
)
return
;
class_def
->
accept
(
v
);
}
void
*
BST_MakeClass
::
accept_expr
(
ExprVisitor
*
v
)
{
return
v
->
visit_makeclass
(
this
);
}
void
print_bst
(
BST
*
bst
)
{
PrintVisitor
v
;
bst
->
accept
(
&
v
);
v
.
flush
();
}
void
PrintVisitor
::
printIndent
()
{
for
(
int
i
=
0
;
i
<
indent
;
i
++
)
{
stream
<<
' '
;
}
}
bool
PrintVisitor
::
visit_alias
(
BST_alias
*
node
)
{
stream
<<
node
->
name
.
s
();
if
(
node
->
asname
.
s
().
size
())
stream
<<
" as "
<<
node
->
asname
.
s
();
return
true
;
}
bool
PrintVisitor
::
visit_arguments
(
BST_arguments
*
node
)
{
int
nargs
=
node
->
args
.
size
();
int
ndefault
=
node
->
defaults
.
size
();
for
(
int
i
=
0
;
i
<
nargs
;
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
args
[
i
]
->
accept
(
this
);
if
(
i
>=
nargs
-
ndefault
)
{
stream
<<
"="
;
node
->
defaults
[
i
-
(
nargs
-
ndefault
)]
->
accept
(
this
);
}
}
return
true
;
}
bool
PrintVisitor
::
visit_assert
(
BST_Assert
*
node
)
{
stream
<<
"assert "
;
node
->
test
->
accept
(
this
);
if
(
node
->
msg
)
{
stream
<<
", "
;
node
->
msg
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_assign
(
BST_Assign
*
node
)
{
for
(
int
i
=
0
;
i
<
node
->
targets
.
size
();
i
++
)
{
node
->
targets
[
i
]
->
accept
(
this
);
stream
<<
" = "
;
}
node
->
value
->
accept
(
this
);
return
true
;
}
void
PrintVisitor
::
printOp
(
BST_TYPE
::
BST_TYPE
op_type
)
{
switch
(
op_type
)
{
case
BST_TYPE
:
:
Add
:
stream
<<
'+'
;
break
;
case
BST_TYPE
:
:
BitAnd
:
stream
<<
'&'
;
break
;
case
BST_TYPE
:
:
BitOr
:
stream
<<
'|'
;
break
;
case
BST_TYPE
:
:
BitXor
:
stream
<<
'^'
;
break
;
case
BST_TYPE
:
:
Div
:
stream
<<
'/'
;
break
;
case
BST_TYPE
:
:
LShift
:
stream
<<
"<<"
;
break
;
case
BST_TYPE
:
:
RShift
:
stream
<<
">>"
;
break
;
case
BST_TYPE
:
:
Pow
:
stream
<<
"**"
;
break
;
case
BST_TYPE
:
:
Mod
:
stream
<<
'%'
;
break
;
case
BST_TYPE
:
:
Mult
:
stream
<<
'*'
;
break
;
case
BST_TYPE
:
:
Sub
:
stream
<<
'-'
;
break
;
default:
stream
<<
"<"
<<
(
int
)
op_type
<<
">"
;
break
;
}
}
bool
PrintVisitor
::
visit_augassign
(
BST_AugAssign
*
node
)
{
node
->
target
->
accept
(
this
);
printOp
(
node
->
op_type
);
stream
<<
'='
;
node
->
value
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_augbinop
(
BST_AugBinOp
*
node
)
{
node
->
left
->
accept
(
this
);
stream
<<
'='
;
printOp
(
node
->
op_type
);
node
->
right
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_attribute
(
BST_Attribute
*
node
)
{
node
->
value
->
accept
(
this
);
stream
<<
'.'
;
stream
<<
node
->
attr
.
s
();
return
true
;
}
bool
PrintVisitor
::
visit_binop
(
BST_BinOp
*
node
)
{
node
->
left
->
accept
(
this
);
printOp
(
node
->
op_type
);
node
->
right
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_boolop
(
BST_BoolOp
*
node
)
{
for
(
int
i
=
0
;
i
<
node
->
values
.
size
();
i
++
)
{
node
->
values
[
i
]
->
accept
(
this
);
if
(
i
==
node
->
values
.
size
()
-
1
)
continue
;
switch
(
node
->
op_type
)
{
case
BST_TYPE
:
:
And
:
stream
<<
" and "
;
break
;
case
BST_TYPE
:
:
Or
:
stream
<<
" or "
;
break
;
default:
ASSERT
(
0
,
"%d"
,
node
->
op_type
);
break
;
}
}
return
true
;
}
bool
PrintVisitor
::
visit_break
(
BST_Break
*
node
)
{
stream
<<
"break"
;
return
true
;
}
bool
PrintVisitor
::
visit_call
(
BST_Call
*
node
)
{
node
->
func
->
accept
(
this
);
stream
<<
"("
;
bool
prevarg
=
false
;
for
(
int
i
=
0
;
i
<
node
->
args
.
size
();
i
++
)
{
if
(
prevarg
)
stream
<<
", "
;
node
->
args
[
i
]
->
accept
(
this
);
prevarg
=
true
;
}
for
(
int
i
=
0
;
i
<
node
->
keywords
.
size
();
i
++
)
{
if
(
prevarg
)
stream
<<
", "
;
node
->
keywords
[
i
]
->
accept
(
this
);
prevarg
=
true
;
}
if
(
node
->
starargs
)
{
if
(
prevarg
)
stream
<<
", "
;
node
->
starargs
->
accept
(
this
);
prevarg
=
true
;
}
if
(
node
->
kwargs
)
{
if
(
prevarg
)
stream
<<
", "
;
node
->
kwargs
->
accept
(
this
);
prevarg
=
true
;
}
stream
<<
")"
;
return
true
;
}
bool
PrintVisitor
::
visit_compare
(
BST_Compare
*
node
)
{
node
->
left
->
accept
(
this
);
for
(
int
i
=
0
;
i
<
node
->
ops
.
size
();
i
++
)
{
std
::
string
symbol
=
getOpSymbol
(
node
->
ops
[
i
]);
stream
<<
" "
<<
symbol
<<
" "
;
node
->
comparators
[
i
]
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_comprehension
(
BST_comprehension
*
node
)
{
stream
<<
"for "
;
node
->
target
->
accept
(
this
);
stream
<<
" in "
;
node
->
iter
->
accept
(
this
);
for
(
BST_expr
*
i
:
node
->
ifs
)
{
stream
<<
" if "
;
i
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_classdef
(
BST_ClassDef
*
node
)
{
for
(
int
i
=
0
,
n
=
node
->
decorator_list
.
size
();
i
<
n
;
i
++
)
{
stream
<<
"@"
;
node
->
decorator_list
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
printIndent
();
}
stream
<<
"class "
<<
node
->
name
.
s
()
<<
"("
;
for
(
int
i
=
0
,
n
=
node
->
bases
.
size
();
i
<
n
;
i
++
)
{
if
(
i
)
stream
<<
", "
;
node
->
bases
[
i
]
->
accept
(
this
);
}
stream
<<
")"
;
indent
+=
4
;
for
(
int
i
=
0
,
n
=
node
->
body
.
size
();
i
<
n
;
i
++
)
{
stream
<<
"
\n
"
;
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
}
indent
-=
4
;
return
true
;
}
bool
PrintVisitor
::
visit_continue
(
BST_Continue
*
node
)
{
stream
<<
"continue"
;
return
true
;
}
bool
PrintVisitor
::
visit_delete
(
BST_Delete
*
node
)
{
stream
<<
"del "
;
for
(
int
i
=
0
;
i
<
node
->
targets
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
targets
[
i
]
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_dict
(
BST_Dict
*
node
)
{
stream
<<
"{"
;
for
(
int
i
=
0
;
i
<
node
->
keys
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
keys
[
i
]
->
accept
(
this
);
stream
<<
":"
;
node
->
values
[
i
]
->
accept
(
this
);
}
stream
<<
"}"
;
return
true
;
}
bool
PrintVisitor
::
visit_dictcomp
(
BST_DictComp
*
node
)
{
stream
<<
"{"
;
node
->
key
->
accept
(
this
);
stream
<<
":"
;
node
->
value
->
accept
(
this
);
for
(
auto
c
:
node
->
generators
)
{
stream
<<
" "
;
c
->
accept
(
this
);
}
stream
<<
"}"
;
return
true
;
}
bool
PrintVisitor
::
visit_ellipsis
(
BST_Ellipsis
*
)
{
stream
<<
"..."
;
return
true
;
}
bool
PrintVisitor
::
visit_excepthandler
(
BST_ExceptHandler
*
node
)
{
stream
<<
"except"
;
if
(
node
->
type
)
{
stream
<<
" "
;
node
->
type
->
accept
(
this
);
}
if
(
node
->
name
)
{
stream
<<
" as "
;
node
->
name
->
accept
(
this
);
}
stream
<<
":
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
body
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
return
true
;
}
bool
PrintVisitor
::
visit_exec
(
BST_Exec
*
node
)
{
stream
<<
"exec "
;
node
->
body
->
accept
(
this
);
if
(
node
->
globals
)
{
stream
<<
" in "
;
node
->
globals
->
accept
(
this
);
if
(
node
->
locals
)
{
stream
<<
", "
;
node
->
locals
->
accept
(
this
);
}
}
stream
<<
"
\n
"
;
return
true
;
}
bool
PrintVisitor
::
visit_expr
(
BST_Expr
*
node
)
{
return
false
;
}
bool
PrintVisitor
::
visit_extslice
(
BST_ExtSlice
*
node
)
{
for
(
int
i
=
0
;
i
<
node
->
dims
.
size
();
++
i
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
dims
[
i
]
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_for
(
BST_For
*
node
)
{
stream
<<
"<for loop>
\n
"
;
return
true
;
}
bool
PrintVisitor
::
visit_functiondef
(
BST_FunctionDef
*
node
)
{
for
(
auto
d
:
node
->
decorator_list
)
{
stream
<<
"@"
;
d
->
accept
(
this
);
stream
<<
"
\n
"
;
printIndent
();
}
stream
<<
"def "
;
if
(
node
->
name
!=
InternedString
())
stream
<<
node
->
name
.
s
();
else
stream
<<
"<lambda>"
;
stream
<<
"("
;
node
->
args
->
accept
(
this
);
stream
<<
")"
;
indent
+=
4
;
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
stream
<<
"
\n
"
;
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
}
indent
-=
4
;
return
true
;
}
bool
PrintVisitor
::
visit_generatorexp
(
BST_GeneratorExp
*
node
)
{
stream
<<
"["
;
node
->
elt
->
accept
(
this
);
for
(
auto
c
:
node
->
generators
)
{
stream
<<
" "
;
c
->
accept
(
this
);
}
stream
<<
"]"
;
return
true
;
}
bool
PrintVisitor
::
visit_global
(
BST_Global
*
node
)
{
stream
<<
"global "
;
for
(
int
i
=
0
;
i
<
node
->
names
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
stream
<<
node
->
names
[
i
].
s
();
}
return
true
;
}
bool
PrintVisitor
::
visit_if
(
BST_If
*
node
)
{
stream
<<
"if "
;
node
->
test
->
accept
(
this
);
stream
<<
":
\n
"
;
indent
+=
4
;
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
if
(
node
->
orelse
.
size
())
{
printIndent
();
bool
elif
=
false
;
if
(
node
->
orelse
.
size
()
==
1
&&
node
->
orelse
[
0
]
->
type
==
BST_TYPE
::
If
)
elif
=
true
;
if
(
elif
)
{
stream
<<
"el"
;
}
else
{
stream
<<
"else:
\n
"
;
indent
+=
4
;
}
for
(
int
i
=
0
;
i
<
node
->
orelse
.
size
();
i
++
)
{
if
(
i
)
stream
<<
"
\n
"
;
printIndent
();
node
->
orelse
[
i
]
->
accept
(
this
);
}
if
(
!
elif
)
indent
-=
4
;
}
return
true
;
}
bool
PrintVisitor
::
visit_ifexp
(
BST_IfExp
*
node
)
{
node
->
body
->
accept
(
this
);
stream
<<
" if "
;
node
->
test
->
accept
(
this
);
stream
<<
" else "
;
node
->
orelse
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_import
(
BST_Import
*
node
)
{
stream
<<
"import "
;
for
(
int
i
=
0
;
i
<
node
->
names
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
names
[
i
]
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_importfrom
(
BST_ImportFrom
*
node
)
{
stream
<<
"from "
<<
node
->
module
.
s
()
<<
" import "
;
for
(
int
i
=
0
;
i
<
node
->
names
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
names
[
i
]
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_index
(
BST_Index
*
node
)
{
return
false
;
}
bool
PrintVisitor
::
visit_invoke
(
BST_Invoke
*
node
)
{
stream
<<
"invoke "
<<
node
->
normal_dest
->
idx
<<
" "
<<
node
->
exc_dest
->
idx
<<
": "
;
node
->
stmt
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_lambda
(
BST_Lambda
*
node
)
{
stream
<<
"lambda "
;
node
->
args
->
accept
(
this
);
stream
<<
": "
;
node
->
body
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_langprimitive
(
BST_LangPrimitive
*
node
)
{
stream
<<
":"
;
switch
(
node
->
opcode
)
{
case
BST_LangPrimitive
:
:
CHECK_EXC_MATCH
:
stream
<<
"CHECK_EXC_MATCH"
;
break
;
case
BST_LangPrimitive
:
:
LANDINGPAD
:
stream
<<
"LANDINGPAD"
;
break
;
case
BST_LangPrimitive
:
:
LOCALS
:
stream
<<
"LOCALS"
;
break
;
case
BST_LangPrimitive
:
:
GET_ITER
:
stream
<<
"GET_ITER"
;
break
;
case
BST_LangPrimitive
:
:
IMPORT_FROM
:
stream
<<
"IMPORT_FROM"
;
break
;
case
BST_LangPrimitive
:
:
IMPORT_NAME
:
stream
<<
"IMPORT_NAME"
;
break
;
case
BST_LangPrimitive
:
:
IMPORT_STAR
:
stream
<<
"IMPORT_STAR"
;
break
;
case
BST_LangPrimitive
:
:
NONE
:
stream
<<
"NONE"
;
break
;
case
BST_LangPrimitive
:
:
NONZERO
:
stream
<<
"NONZERO"
;
break
;
case
BST_LangPrimitive
:
:
SET_EXC_INFO
:
stream
<<
"SET_EXC_INFO"
;
break
;
case
BST_LangPrimitive
:
:
UNCACHE_EXC_INFO
:
stream
<<
"UNCACHE_EXC_INFO"
;
break
;
case
BST_LangPrimitive
:
:
HASNEXT
:
stream
<<
"HASNEXT"
;
break
;
case
BST_LangPrimitive
:
:
PRINT_EXPR
:
stream
<<
"PRINT_EXPR"
;
break
;
default:
RELEASE_ASSERT
(
0
,
"%d"
,
node
->
opcode
);
}
stream
<<
"("
;
for
(
int
i
=
0
,
n
=
node
->
args
.
size
();
i
<
n
;
++
i
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
args
[
i
]
->
accept
(
this
);
}
stream
<<
")"
;
return
true
;
}
bool
PrintVisitor
::
visit_list
(
BST_List
*
node
)
{
stream
<<
"["
;
for
(
int
i
=
0
,
n
=
node
->
elts
.
size
();
i
<
n
;
++
i
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
elts
[
i
]
->
accept
(
this
);
}
stream
<<
"]"
;
return
true
;
}
bool
PrintVisitor
::
visit_listcomp
(
BST_ListComp
*
node
)
{
stream
<<
"["
;
node
->
elt
->
accept
(
this
);
for
(
auto
c
:
node
->
generators
)
{
stream
<<
" "
;
c
->
accept
(
this
);
}
stream
<<
"]"
;
return
true
;
}
bool
PrintVisitor
::
visit_keyword
(
BST_keyword
*
node
)
{
stream
<<
node
->
arg
.
s
()
<<
"="
;
node
->
value
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_module
(
BST_Module
*
node
)
{
// stream << "<module>\n";
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
node
->
body
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
}
return
true
;
}
bool
PrintVisitor
::
visit_expression
(
BST_Expression
*
node
)
{
node
->
body
->
accept
(
this
);
stream
<<
"
\n
"
;
return
true
;
}
bool
PrintVisitor
::
visit_suite
(
BST_Suite
*
node
)
{
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
}
return
true
;
}
bool
PrintVisitor
::
visit_name
(
BST_Name
*
node
)
{
stream
<<
node
->
id
.
s
();
#if 0
if (node->lookup_type == ScopeInfo::VarScopeType::UNKNOWN)
stream << "<U>";
else if (node->lookup_type == ScopeInfo::VarScopeType::FBST)
stream << "<F>";
else if (node->lookup_type == ScopeInfo::VarScopeType::DEREF)
stream << "<D>";
else if (node->lookup_type == ScopeInfo::VarScopeType::CLOSURE)
stream << "<C>";
else if (node->lookup_type == ScopeInfo::VarScopeType::GLOBAL)
stream << "<G>";
else
stream << "<?>";
#endif
#if 0
if (node->is_kill) stream << "<k>";
#endif
return
false
;
}
bool
PrintVisitor
::
visit_num
(
BST_Num
*
node
)
{
if
(
node
->
num_type
==
BST_Num
::
INT
)
{
stream
<<
node
->
n_int
;
}
else
if
(
node
->
num_type
==
BST_Num
::
LONG
)
{
stream
<<
node
->
n_long
<<
"L"
;
}
else
if
(
node
->
num_type
==
BST_Num
::
FLOAT
)
{
stream
<<
node
->
n_float
;
}
else
if
(
node
->
num_type
==
BST_Num
::
COMPLEX
)
{
stream
<<
node
->
n_float
<<
"j"
;
}
else
{
RELEASE_ASSERT
(
0
,
""
);
}
return
false
;
}
bool
PrintVisitor
::
visit_pass
(
BST_Pass
*
node
)
{
stream
<<
"pass"
;
return
true
;
}
bool
PrintVisitor
::
visit_print
(
BST_Print
*
node
)
{
stream
<<
"print "
;
if
(
node
->
dest
)
{
stream
<<
">>"
;
node
->
dest
->
accept
(
this
);
stream
<<
", "
;
}
for
(
int
i
=
0
;
i
<
node
->
values
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
", "
;
node
->
values
[
i
]
->
accept
(
this
);
}
if
(
!
node
->
nl
)
stream
<<
","
;
return
true
;
}
bool
PrintVisitor
::
visit_raise
(
BST_Raise
*
node
)
{
stream
<<
"raise"
;
if
(
node
->
arg0
)
{
stream
<<
" "
;
node
->
arg0
->
accept
(
this
);
}
if
(
node
->
arg1
)
{
stream
<<
", "
;
node
->
arg1
->
accept
(
this
);
}
if
(
node
->
arg2
)
{
stream
<<
", "
;
node
->
arg2
->
accept
(
this
);
}
return
true
;
}
bool
PrintVisitor
::
visit_repr
(
BST_Repr
*
node
)
{
stream
<<
"`"
;
node
->
value
->
accept
(
this
);
stream
<<
"`"
;
return
true
;
}
bool
PrintVisitor
::
visit_return
(
BST_Return
*
node
)
{
stream
<<
"return "
;
return
false
;
}
bool
PrintVisitor
::
visit_set
(
BST_Set
*
node
)
{
// An empty set literal is not writeable in Python (it's a dictionary),
// but we sometimes generate it (ex in set comprehension lowering).
// Just to make it clear when printing, print empty set literals as "SET{}".
if
(
!
node
->
elts
.
size
())
stream
<<
"SET"
;
stream
<<
"{"
;
bool
first
=
true
;
for
(
auto
e
:
node
->
elts
)
{
if
(
!
first
)
stream
<<
", "
;
first
=
false
;
e
->
accept
(
this
);
}
stream
<<
"}"
;
return
true
;
}
bool
PrintVisitor
::
visit_setcomp
(
BST_SetComp
*
node
)
{
stream
<<
"{"
;
node
->
elt
->
accept
(
this
);
for
(
auto
c
:
node
->
generators
)
{
stream
<<
" "
;
c
->
accept
(
this
);
}
stream
<<
"}"
;
return
true
;
}
bool
PrintVisitor
::
visit_slice
(
BST_Slice
*
node
)
{
stream
<<
"<slice>("
;
if
(
node
->
lower
)
node
->
lower
->
accept
(
this
);
if
(
node
->
upper
||
node
->
step
)
stream
<<
':'
;
if
(
node
->
upper
)
node
->
upper
->
accept
(
this
);
if
(
node
->
step
)
{
stream
<<
':'
;
node
->
step
->
accept
(
this
);
}
stream
<<
")"
;
return
true
;
}
bool
PrintVisitor
::
visit_str
(
BST_Str
*
node
)
{
if
(
node
->
str_type
==
BST_Str
::
STR
)
{
stream
<<
"
\"
"
<<
node
->
str_data
<<
"
\"
"
;
}
else
if
(
node
->
str_type
==
BST_Str
::
UNICODE
)
{
stream
<<
"<unicode value>"
;
}
else
{
RELEASE_ASSERT
(
0
,
"%d"
,
node
->
str_type
);
}
return
false
;
}
bool
PrintVisitor
::
visit_subscript
(
BST_Subscript
*
node
)
{
node
->
value
->
accept
(
this
);
stream
<<
"["
;
node
->
slice
->
accept
(
this
);
stream
<<
"]"
;
return
true
;
}
bool
PrintVisitor
::
visit_tryexcept
(
BST_TryExcept
*
node
)
{
stream
<<
"try:
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
body
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
for
(
BST_ExceptHandler
*
handler
:
node
->
handlers
)
{
printIndent
();
handler
->
accept
(
this
);
}
if
(
node
->
orelse
.
size
())
{
printIndent
();
stream
<<
"else:
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
orelse
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
}
return
true
;
}
bool
PrintVisitor
::
visit_tryfinally
(
BST_TryFinally
*
node
)
{
if
(
node
->
body
.
size
()
==
1
&&
node
->
body
[
0
]
->
type
==
BST_TYPE
::
TryExcept
)
{
node
->
body
[
0
]
->
accept
(
this
);
printIndent
();
stream
<<
"finally:
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
finalbody
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
}
else
{
stream
<<
"try:
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
body
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
printIndent
();
stream
<<
"finally:
\n
"
;
indent
+=
4
;
for
(
BST
*
subnode
:
node
->
finalbody
)
{
printIndent
();
subnode
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
}
return
true
;
}
bool
PrintVisitor
::
visit_tuple
(
BST_Tuple
*
node
)
{
stream
<<
"("
;
int
n
=
node
->
elts
.
size
();
for
(
int
i
=
0
;
i
<
n
;
i
++
)
{
if
(
i
)
stream
<<
", "
;
node
->
elts
[
i
]
->
accept
(
this
);
}
if
(
n
==
1
)
stream
<<
","
;
stream
<<
")"
;
return
true
;
}
bool
PrintVisitor
::
visit_unaryop
(
BST_UnaryOp
*
node
)
{
switch
(
node
->
op_type
)
{
case
BST_TYPE
:
:
Invert
:
stream
<<
"~"
;
break
;
case
BST_TYPE
:
:
Not
:
stream
<<
"not "
;
break
;
case
BST_TYPE
:
:
UAdd
:
stream
<<
"+"
;
break
;
case
BST_TYPE
:
:
USub
:
stream
<<
"-"
;
break
;
default:
RELEASE_ASSERT
(
0
,
"%s"
,
getOpName
(
node
->
op_type
)
->
c_str
());
break
;
}
stream
<<
"("
;
node
->
operand
->
accept
(
this
);
stream
<<
")"
;
return
true
;
}
bool
PrintVisitor
::
visit_while
(
BST_While
*
node
)
{
stream
<<
"while "
;
node
->
test
->
accept
(
this
);
stream
<<
"
\n
"
;
indent
+=
4
;
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
if
(
node
->
orelse
.
size
())
{
printIndent
();
stream
<<
"else
\n
"
;
indent
+=
4
;
for
(
int
i
=
0
;
i
<
node
->
orelse
.
size
();
i
++
)
{
printIndent
();
node
->
orelse
[
i
]
->
accept
(
this
);
stream
<<
"
\n
"
;
}
indent
-=
4
;
}
return
true
;
}
bool
PrintVisitor
::
visit_with
(
BST_With
*
node
)
{
stream
<<
"with "
;
node
->
context_expr
->
accept
(
this
);
if
(
node
->
optional_vars
)
{
stream
<<
" as "
;
node
->
optional_vars
->
accept
(
this
);
stream
<<
":
\n
"
;
}
indent
+=
4
;
for
(
int
i
=
0
;
i
<
node
->
body
.
size
();
i
++
)
{
if
(
i
>
0
)
stream
<<
"
\n
"
;
printIndent
();
node
->
body
[
i
]
->
accept
(
this
);
}
indent
-=
4
;
return
true
;
}
bool
PrintVisitor
::
visit_yield
(
BST_Yield
*
node
)
{
stream
<<
"yield "
;
if
(
node
->
value
)
node
->
value
->
accept
(
this
);
return
true
;
}
bool
PrintVisitor
::
visit_branch
(
BST_Branch
*
node
)
{
stream
<<
"if "
;
node
->
test
->
accept
(
this
);
stream
<<
" goto "
<<
node
->
iftrue
->
idx
<<
" else goto "
<<
node
->
iffalse
->
idx
;
return
true
;
}
bool
PrintVisitor
::
visit_jump
(
BST_Jump
*
node
)
{
stream
<<
"goto "
<<
node
->
target
->
idx
;
return
true
;
}
bool
PrintVisitor
::
visit_clsattribute
(
BST_ClsAttribute
*
node
)
{
// printf("getclsattr(");
// node->value->accept(this);
// printf(", '%s')", node->attr.c_str());
node
->
value
->
accept
(
this
);
stream
<<
":"
<<
node
->
attr
.
s
();
return
true
;
}
bool
PrintVisitor
::
visit_makefunction
(
BST_MakeFunction
*
node
)
{
stream
<<
"make_"
;
return
false
;
}
bool
PrintVisitor
::
visit_makeclass
(
BST_MakeClass
*
node
)
{
stream
<<
"make_"
;
return
false
;
}
class
FlattenVisitor
:
public
BSTVisitor
{
private:
std
::
vector
<
BST
*>*
output
;
bool
expand_scopes
;
public:
FlattenVisitor
(
std
::
vector
<
BST
*>*
output
,
bool
expand_scopes
)
:
output
(
output
),
expand_scopes
(
expand_scopes
)
{
assert
(
expand_scopes
&&
"not sure if this works properly"
);
}
virtual
bool
visit_alias
(
BST_alias
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_arguments
(
BST_arguments
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_assert
(
BST_Assert
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_assign
(
BST_Assign
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_augassign
(
BST_AugAssign
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_augbinop
(
BST_AugBinOp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_attribute
(
BST_Attribute
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_binop
(
BST_BinOp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_boolop
(
BST_BoolOp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_break
(
BST_Break
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_call
(
BST_Call
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_classdef
(
BST_ClassDef
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_compare
(
BST_Compare
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_comprehension
(
BST_comprehension
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_continue
(
BST_Continue
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_delete
(
BST_Delete
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_dict
(
BST_Dict
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_dictcomp
(
BST_DictComp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_ellipsis
(
BST_Ellipsis
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_excepthandler
(
BST_ExceptHandler
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_exec
(
BST_Exec
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_expr
(
BST_Expr
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_extslice
(
BST_ExtSlice
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_for
(
BST_For
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_functiondef
(
BST_FunctionDef
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_generatorexp
(
BST_GeneratorExp
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_global
(
BST_Global
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_if
(
BST_If
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_ifexp
(
BST_IfExp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_import
(
BST_Import
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_importfrom
(
BST_ImportFrom
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_index
(
BST_Index
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_invoke
(
BST_Invoke
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_keyword
(
BST_keyword
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_lambda
(
BST_Lambda
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_langprimitive
(
BST_LangPrimitive
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_list
(
BST_List
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_listcomp
(
BST_ListComp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_module
(
BST_Module
*
node
)
{
output
->
push_back
(
node
);
return
!
expand_scopes
;
}
virtual
bool
visit_name
(
BST_Name
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_num
(
BST_Num
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_pass
(
BST_Pass
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_print
(
BST_Print
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_raise
(
BST_Raise
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_repr
(
BST_Repr
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_return
(
BST_Return
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_set
(
BST_Set
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_setcomp
(
BST_SetComp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_slice
(
BST_Slice
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_str
(
BST_Str
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_subscript
(
BST_Subscript
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_tryexcept
(
BST_TryExcept
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_tryfinally
(
BST_TryFinally
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_tuple
(
BST_Tuple
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_unaryop
(
BST_UnaryOp
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_while
(
BST_While
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_with
(
BST_With
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_yield
(
BST_Yield
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_branch
(
BST_Branch
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_jump
(
BST_Jump
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_clsattribute
(
BST_ClsAttribute
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_makeclass
(
BST_MakeClass
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
virtual
bool
visit_makefunction
(
BST_MakeFunction
*
node
)
{
output
->
push_back
(
node
);
return
false
;
}
};
}
src/core/bst.h
0 → 100644
View file @
42a07f21
// Copyright (c) 2014-2016 Dropbox, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef PYSTON_CORE_BST_H
#define PYSTON_CORE_BST_H
#include <cassert>
#include <cstdlib>
#include <map>
#include <stdint.h>
#include <string>
#include <vector>
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include "analysis/scoping_analysis.h"
#include "core/common.h"
#include "core/stringpool.h"
namespace
pyston
{
namespace
BST_TYPE
{
// These are in a pretty random order (started off alphabetical but then I had to add more).
// These can be changed freely as long as parse_ast.py is also updated
#define FOREACH_TYPE(X) \
X(alias, 1) \
X(arguments, 2) \
X(Assert, 3) \
X(Assign, 4) \
X(Attribute, 5) \
X(AugAssign, 6) \
X(BinOp, 7) \
X(BoolOp, 8) \
X(Call, 9) \
X(ClassDef, 10) \
X(Compare, 11) \
X(comprehension, 12) \
X(Delete, 13) \
X(Dict, 14) \
X(Exec, 16) \
X(ExceptHandler, 17) \
X(ExtSlice, 18) \
X(Expr, 19) \
X(For, 20) \
X(FunctionDef, 21) \
X(GeneratorExp, 22) \
X(Global, 23) \
X(If, 24) \
X(IfExp, 25) \
X(Import, 26) \
X(ImportFrom, 27) \
X(Index, 28) \
X(keyword, 29) \
X(Lambda, 30) \
X(List, 31) \
X(ListComp, 32) \
X(Module, 33) \
X(Num, 34) \
X(Name, 35) \
X(Pass, 37) \
X(Pow, 38) \
X(Print, 39) \
X(Raise, 40) \
X(Repr, 41) \
X(Return, 42) \
X(Slice, 44) \
X(Str, 45) \
X(Subscript, 46) \
X(TryExcept, 47) \
X(TryFinally, 48) \
X(Tuple, 49) \
X(UnaryOp, 50) \
X(With, 51) \
X(While, 52) \
X(Yield, 53) \
X(Store, 54) \
X(Load, 55) \
X(Param, 56) \
X(Not, 57) \
X(In, 58) \
X(Is, 59) \
X(IsNot, 60) \
X(Or, 61) \
X(And, 62) \
X(Eq, 63) \
X(NotEq, 64) \
X(NotIn, 65) \
X(GtE, 66) \
X(Gt, 67) \
X(Mod, 68) \
X(Add, 69) \
X(Continue, 70) \
X(Lt, 71) \
X(LtE, 72) \
X(Break, 73) \
X(Sub, 74) \
X(Del, 75) \
X(Mult, 76) \
X(Div, 77) \
X(USub, 78) \
X(BitAnd, 79) \
X(BitOr, 80) \
X(BitXor, 81) \
X(RShift, 82) \
X(LShift, 83) \
X(Invert, 84) \
X(UAdd, 85) \
X(FloorDiv, 86) \
X(DictComp, 15) \
X(Set, 43) \
X(Ellipsis, 87) \
/* like Module, but used for eval. */
\
X(Expression, 88) \
X(SetComp, 89) \
X(Suite, 90) \
\
/* Pseudo-nodes that are specific to this compiler: */
\
X(Branch, 200) \
X(Jump, 201) \
X(ClsAttribute, 202) \
X(AugBinOp, 203) \
X(Invoke, 204) \
X(LangPrimitive, 205) \
/* wraps a ClassDef to make it an expr */
\
X(MakeClass, 206) \
/* wraps a FunctionDef to make it an expr */
\
X(MakeFunction, 207) \
\
/* These aren't real BST types, but since we use BST types to represent binexp types */
\
/* and divmod+truediv are essentially types of binops, we add them here (at least for now): */
\
X(DivMod, 250) \
X(TrueDiv, 251)
#define GENERATE_ENUM(ENUM, N) ENUM = N,
#define GENERATE_STRING(STRING, N) m[N] = #STRING;
enum
BST_TYPE
{
FOREACH_TYPE
(
GENERATE_ENUM
)
};
static
const
char
*
stringify
(
int
n
)
{
static
std
::
map
<
int
,
const
char
*>
m
;
FOREACH_TYPE
(
GENERATE_STRING
)
return
m
[
n
];
}
#undef FOREACH_TYPE
#undef GENERATE_ENUM
#undef GENERATE_STRING
};
class
BSTVisitor
;
class
ExprVisitor
;
class
StmtVisitor
;
class
SliceVisitor
;
class
BST_keyword
;
class
BST
{
public:
virtual
~
BST
()
{}
const
BST_TYPE
::
BST_TYPE
type
;
uint32_t
lineno
,
col_offset
;
virtual
void
accept
(
BSTVisitor
*
v
)
=
0
;
// #define DEBUG_LINE_NUMBERS 1
#ifdef DEBUG_LINE_NUMBERS
private:
// Initialize lineno to something unique, so that if we see something ridiculous
// appear in the traceback, we can isolate the allocation which created it.
static
int
next_lineno
;
public:
BST
(
BST_TYPE
::
BST_TYPE
type
);
#else
BST
(
BST_TYPE
::
BST_TYPE
type
)
:
type
(
type
),
lineno
(
0
),
col_offset
(
0
)
{}
#endif
BST
(
BST_TYPE
::
BST_TYPE
type
,
uint32_t
lineno
,
uint32_t
col_offset
=
0
)
:
type
(
type
),
lineno
(
lineno
),
col_offset
(
col_offset
)
{}
};
class
BST_expr
:
public
BST
{
public:
virtual
void
*
accept_expr
(
ExprVisitor
*
v
)
=
0
;
BST_expr
(
BST_TYPE
::
BST_TYPE
type
)
:
BST
(
type
)
{}
BST_expr
(
BST_TYPE
::
BST_TYPE
type
,
uint32_t
lineno
,
uint32_t
col_offset
=
0
)
:
BST
(
type
,
lineno
,
col_offset
)
{}
};
class
BST_stmt
:
public
BST
{
public:
virtual
void
accept_stmt
(
StmtVisitor
*
v
)
=
0
;
int
cxx_exception_count
=
0
;
BST_stmt
(
BST_TYPE
::
BST_TYPE
type
)
:
BST
(
type
)
{}
};
class
BST_slice
:
public
BST
{
public:
virtual
void
*
accept_slice
(
SliceVisitor
*
s
)
=
0
;
BST_slice
(
BST_TYPE
::
BST_TYPE
type
)
:
BST
(
type
)
{}
BST_slice
(
BST_TYPE
::
BST_TYPE
type
,
uint32_t
lineno
,
uint32_t
col_offset
=
0
)
:
BST
(
type
,
lineno
,
col_offset
)
{}
};
class
BST_alias
:
public
BST
{
public:
InternedString
name
,
asname
;
int
name_vreg
=
-
1
,
asname_vreg
=
-
1
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_alias
(
InternedString
name
,
InternedString
asname
)
:
BST
(
BST_TYPE
::
alias
),
name
(
name
),
asname
(
asname
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
alias
;
};
class
BST_Name
;
class
BST_arguments
:
public
BST
{
public:
// no lineno, col_offset attributes
std
::
vector
<
BST_expr
*>
args
,
defaults
;
BST_Name
*
kwarg
=
NULL
,
*
vararg
=
NULL
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_arguments
()
:
BST
(
BST_TYPE
::
arguments
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
arguments
;
};
class
BST_Assert
:
public
BST_stmt
{
public:
BST_expr
*
msg
,
*
test
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Assert
()
:
BST_stmt
(
BST_TYPE
::
Assert
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Assert
;
};
class
BST_Assign
:
public
BST_stmt
{
public:
std
::
vector
<
BST_expr
*>
targets
;
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Assign
()
:
BST_stmt
(
BST_TYPE
::
Assign
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Assign
;
};
class
BST_AugAssign
:
public
BST_stmt
{
public:
BST_expr
*
value
;
BST_expr
*
target
;
BST_TYPE
::
BST_TYPE
op_type
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_AugAssign
()
:
BST_stmt
(
BST_TYPE
::
AugAssign
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
AugAssign
;
};
class
BST_AugBinOp
:
public
BST_expr
{
public:
BST_TYPE
::
BST_TYPE
op_type
;
BST_expr
*
left
,
*
right
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_AugBinOp
()
:
BST_expr
(
BST_TYPE
::
AugBinOp
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
AugBinOp
;
};
class
BST_Attribute
:
public
BST_expr
{
public:
BST_expr
*
value
;
BST_TYPE
::
BST_TYPE
ctx_type
;
InternedString
attr
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Attribute
()
:
BST_expr
(
BST_TYPE
::
Attribute
)
{}
BST_Attribute
(
BST_expr
*
value
,
BST_TYPE
::
BST_TYPE
ctx_type
,
InternedString
attr
)
:
BST_expr
(
BST_TYPE
::
Attribute
),
value
(
value
),
ctx_type
(
ctx_type
),
attr
(
attr
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Attribute
;
};
class
BST_BinOp
:
public
BST_expr
{
public:
BST_TYPE
::
BST_TYPE
op_type
;
BST_expr
*
left
,
*
right
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_BinOp
()
:
BST_expr
(
BST_TYPE
::
BinOp
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
BinOp
;
};
class
BST_BoolOp
:
public
BST_expr
{
public:
BST_TYPE
::
BST_TYPE
op_type
;
std
::
vector
<
BST_expr
*>
values
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_BoolOp
()
:
BST_expr
(
BST_TYPE
::
BoolOp
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
BoolOp
;
};
class
BST_Break
:
public
BST_stmt
{
public:
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Break
()
:
BST_stmt
(
BST_TYPE
::
Break
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Break
;
};
class
BST_Call
:
public
BST_expr
{
public:
BST_expr
*
starargs
,
*
kwargs
,
*
func
;
std
::
vector
<
BST_expr
*>
args
;
std
::
vector
<
BST_keyword
*>
keywords
;
// used during execution stores all keyword names
std
::
unique_ptr
<
std
::
vector
<
BoxedString
*>>
keywords_names
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Call
()
:
BST_expr
(
BST_TYPE
::
Call
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Call
;
};
class
BST_Compare
:
public
BST_expr
{
public:
std
::
vector
<
BST_TYPE
::
BST_TYPE
>
ops
;
std
::
vector
<
BST_expr
*>
comparators
;
BST_expr
*
left
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Compare
()
:
BST_expr
(
BST_TYPE
::
Compare
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Compare
;
};
class
BST_comprehension
:
public
BST
{
public:
BST_expr
*
target
;
BST_expr
*
iter
;
std
::
vector
<
BST_expr
*>
ifs
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_comprehension
()
:
BST
(
BST_TYPE
::
comprehension
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
comprehension
;
};
class
BST_ClassDef
:
public
BST_stmt
{
public:
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
std
::
vector
<
BST_expr
*>
bases
,
decorator_list
;
std
::
vector
<
BST_stmt
*>
body
;
InternedString
name
;
BoxedCode
*
code
;
BST_ClassDef
()
:
BST_stmt
(
BST_TYPE
::
ClassDef
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ClassDef
;
};
class
BST_Continue
:
public
BST_stmt
{
public:
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Continue
()
:
BST_stmt
(
BST_TYPE
::
Continue
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Continue
;
};
class
BST_Dict
:
public
BST_expr
{
public:
std
::
vector
<
BST_expr
*>
keys
,
values
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Dict
()
:
BST_expr
(
BST_TYPE
::
Dict
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Dict
;
};
class
BST_DictComp
:
public
BST_expr
{
public:
std
::
vector
<
BST_comprehension
*>
generators
;
BST_expr
*
key
,
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_DictComp
()
:
BST_expr
(
BST_TYPE
::
DictComp
)
{}
const
static
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
DictComp
;
};
class
BST_Delete
:
public
BST_stmt
{
public:
std
::
vector
<
BST_expr
*>
targets
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Delete
()
:
BST_stmt
(
BST_TYPE
::
Delete
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Delete
;
};
class
BST_Ellipsis
:
public
BST_slice
{
public:
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_slice
(
SliceVisitor
*
v
);
BST_Ellipsis
()
:
BST_slice
(
BST_TYPE
::
Ellipsis
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Ellipsis
;
};
class
BST_Expr
:
public
BST_stmt
{
public:
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Expr
()
:
BST_stmt
(
BST_TYPE
::
Expr
)
{}
BST_Expr
(
BST_expr
*
value
)
:
BST_stmt
(
BST_TYPE
::
Expr
),
value
(
value
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Expr
;
};
class
BST_ExceptHandler
:
public
BST
{
public:
std
::
vector
<
BST_stmt
*>
body
;
BST_expr
*
type
;
// can be NULL for a bare "except:" clause
BST_expr
*
name
;
// can be NULL if the exception doesn't get a name
virtual
void
accept
(
BSTVisitor
*
v
);
BST_ExceptHandler
()
:
BST
(
BST_TYPE
::
ExceptHandler
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ExceptHandler
;
};
class
BST_Exec
:
public
BST_stmt
{
public:
BST_expr
*
body
;
BST_expr
*
globals
;
BST_expr
*
locals
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Exec
()
:
BST_stmt
(
BST_TYPE
::
Exec
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Exec
;
};
// (Alternative to BST_Module, used for, e.g., eval)
class
BST_Expression
:
public
BST
{
public:
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
;
// this should be an expr but we convert it into a BST_Return(BST_expr) to make the code simpler
BST_stmt
*
body
;
BoxedCode
*
code
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_Expression
(
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
)
:
BST
(
BST_TYPE
::
Expression
),
interned_strings
(
std
::
move
(
interned_strings
))
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Expression
;
};
class
BST_ExtSlice
:
public
BST_slice
{
public:
std
::
vector
<
BST_slice
*>
dims
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_slice
(
SliceVisitor
*
v
);
BST_ExtSlice
()
:
BST_slice
(
BST_TYPE
::
ExtSlice
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ExtSlice
;
};
class
BST_For
:
public
BST_stmt
{
public:
std
::
vector
<
BST_stmt
*>
body
,
orelse
;
BST_expr
*
target
,
*
iter
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_For
()
:
BST_stmt
(
BST_TYPE
::
For
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
For
;
};
class
BST_FunctionDef
:
public
BST_stmt
{
public:
std
::
vector
<
BST_stmt
*>
body
;
std
::
vector
<
BST_expr
*>
decorator_list
;
InternedString
name
;
// if the name is not set this is a lambda
BST_arguments
*
args
;
BoxedCode
*
code
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_FunctionDef
()
:
BST_stmt
(
BST_TYPE
::
FunctionDef
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
FunctionDef
;
};
class
BST_GeneratorExp
:
public
BST_expr
{
public:
std
::
vector
<
BST_comprehension
*>
generators
;
BST_expr
*
elt
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_GeneratorExp
()
:
BST_expr
(
BST_TYPE
::
GeneratorExp
)
{}
const
static
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
GeneratorExp
;
};
class
BST_Global
:
public
BST_stmt
{
public:
std
::
vector
<
InternedString
>
names
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Global
()
:
BST_stmt
(
BST_TYPE
::
Global
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Global
;
};
class
BST_If
:
public
BST_stmt
{
public:
std
::
vector
<
BST_stmt
*>
body
,
orelse
;
BST_expr
*
test
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_If
()
:
BST_stmt
(
BST_TYPE
::
If
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
If
;
};
class
BST_IfExp
:
public
BST_expr
{
public:
BST_expr
*
body
,
*
test
,
*
orelse
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_IfExp
()
:
BST_expr
(
BST_TYPE
::
IfExp
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
IfExp
;
};
class
BST_Import
:
public
BST_stmt
{
public:
std
::
vector
<
BST_alias
*>
names
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Import
()
:
BST_stmt
(
BST_TYPE
::
Import
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Import
;
};
class
BST_ImportFrom
:
public
BST_stmt
{
public:
InternedString
module
;
std
::
vector
<
BST_alias
*>
names
;
int
level
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_ImportFrom
()
:
BST_stmt
(
BST_TYPE
::
ImportFrom
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ImportFrom
;
};
class
BST_Index
:
public
BST_slice
{
public:
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_slice
(
SliceVisitor
*
v
);
BST_Index
()
:
BST_slice
(
BST_TYPE
::
Index
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Index
;
};
class
BST_keyword
:
public
BST
{
public:
// no lineno, col_offset attributes
BST_expr
*
value
;
InternedString
arg
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_keyword
()
:
BST
(
BST_TYPE
::
keyword
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
keyword
;
};
class
BST_Lambda
:
public
BST_expr
{
public:
BST_arguments
*
args
;
BST_expr
*
body
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Lambda
()
:
BST_expr
(
BST_TYPE
::
Lambda
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Lambda
;
};
class
BST_List
:
public
BST_expr
{
public:
std
::
vector
<
BST_expr
*>
elts
;
BST_TYPE
::
BST_TYPE
ctx_type
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_List
()
:
BST_expr
(
BST_TYPE
::
List
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
List
;
};
class
BST_ListComp
:
public
BST_expr
{
public:
std
::
vector
<
BST_comprehension
*>
generators
;
BST_expr
*
elt
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_ListComp
()
:
BST_expr
(
BST_TYPE
::
ListComp
)
{}
const
static
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ListComp
;
};
class
BST_Module
:
public
BST
{
public:
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
;
// no lineno, col_offset attributes
std
::
vector
<
BST_stmt
*>
body
;
BoxedCode
*
code
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_Module
(
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
)
:
BST
(
BST_TYPE
::
Module
),
interned_strings
(
std
::
move
(
interned_strings
))
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Module
;
};
class
BST_Suite
:
public
BST
{
public:
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
;
std
::
vector
<
BST_stmt
*>
body
;
virtual
void
accept
(
BSTVisitor
*
v
);
BST_Suite
(
std
::
unique_ptr
<
InternedStringPool
>
interned_strings
)
:
BST
(
BST_TYPE
::
Suite
),
interned_strings
(
std
::
move
(
interned_strings
))
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Suite
;
};
class
BST_Name
:
public
BST_expr
{
public:
BST_TYPE
::
BST_TYPE
ctx_type
;
InternedString
id
;
// The resolved scope of this name. Kind of hacky to be storing it in the BST node;
// in CPython it ends up getting "cached" by being translated into one of a number of
// different bytecodes.
ScopeInfo
::
VarScopeType
lookup_type
;
// These are only valid for lookup_type == FBST or CLOSURE
// The interpreter and baseline JIT store variables with FBST and CLOSURE scopes in an array (vregs) this specifies
// the zero based index of this variable inside the vregs array. If uninitialized it's value is -1.
int
vreg
;
bool
is_kill
=
false
;
// Only valid for lookup_type == DEREF:
DerefInfo
deref_info
=
DerefInfo
({
INT_MAX
,
INT_MAX
});
// Only valid for lookup_type == CLOSURE:
int
closure_offset
=
-
1
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Name
(
InternedString
id
,
BST_TYPE
::
BST_TYPE
ctx_type
,
int
lineno
,
int
col_offset
=
0
)
:
BST_expr
(
BST_TYPE
::
Name
,
lineno
,
col_offset
),
ctx_type
(
ctx_type
),
id
(
id
),
lookup_type
(
ScopeInfo
::
VarScopeType
::
UNKNOWN
),
vreg
(
-
1
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Name
;
};
class
BST_Num
:
public
BST_expr
{
public:
enum
NumType
{
// These values must correspond to the values in parse_ast.py
INT
=
0x10
,
FLOAT
=
0x20
,
LONG
=
0x30
,
// for COMPLEX, n_float is the imaginary part, real part is 0
COMPLEX
=
0x40
,
}
num_type
;
union
{
int64_t
n_int
;
double
n_float
;
};
std
::
string
n_long
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Num
()
:
BST_expr
(
BST_TYPE
::
Num
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Num
;
};
class
BST_Repr
:
public
BST_expr
{
public:
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Repr
()
:
BST_expr
(
BST_TYPE
::
Repr
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Repr
;
};
class
BST_Pass
:
public
BST_stmt
{
public:
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Pass
()
:
BST_stmt
(
BST_TYPE
::
Pass
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Pass
;
};
class
BST_Print
:
public
BST_stmt
{
public:
BST_expr
*
dest
;
bool
nl
;
std
::
vector
<
BST_expr
*>
values
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Print
()
:
BST_stmt
(
BST_TYPE
::
Print
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Print
;
};
class
BST_Raise
:
public
BST_stmt
{
public:
// In the python ast module, these are called "type", "inst", and "tback", respectively.
// Renaming to arg{0..2} since I find that confusing, since they are filled in
// sequentially rather than semantically.
// Ie "raise Exception()" will have type==Exception(), inst==None, tback==None
BST_expr
*
arg0
,
*
arg1
,
*
arg2
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Raise
()
:
BST_stmt
(
BST_TYPE
::
Raise
),
arg0
(
NULL
),
arg1
(
NULL
),
arg2
(
NULL
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Raise
;
};
class
BST_Return
:
public
BST_stmt
{
public:
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Return
()
:
BST_stmt
(
BST_TYPE
::
Return
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Return
;
};
class
BST_Set
:
public
BST_expr
{
public:
std
::
vector
<
BST_expr
*>
elts
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Set
()
:
BST_expr
(
BST_TYPE
::
Set
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Set
;
};
class
BST_SetComp
:
public
BST_expr
{
public:
std
::
vector
<
BST_comprehension
*>
generators
;
BST_expr
*
elt
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_SetComp
()
:
BST_expr
(
BST_TYPE
::
SetComp
)
{}
const
static
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
SetComp
;
};
class
BST_Slice
:
public
BST_slice
{
public:
BST_expr
*
lower
,
*
upper
,
*
step
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_slice
(
SliceVisitor
*
v
);
BST_Slice
()
:
BST_slice
(
BST_TYPE
::
Slice
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Slice
;
};
class
BST_Str
:
public
BST_expr
{
public:
enum
StrType
{
UNSET
=
0x00
,
STR
=
0x10
,
UNICODE
=
0x20
,
}
str_type
;
// The meaning of str_data depends on str_type. For STR, it's just the bytes value.
// For UNICODE, it's the utf-8 encoded value.
std
::
string
str_data
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Str
()
:
BST_expr
(
BST_TYPE
::
Str
),
str_type
(
UNSET
)
{}
BST_Str
(
std
::
string
s
)
:
BST_expr
(
BST_TYPE
::
Str
),
str_type
(
STR
),
str_data
(
std
::
move
(
s
))
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Str
;
};
class
BST_Subscript
:
public
BST_expr
{
public:
BST_expr
*
value
;
BST_slice
*
slice
;
BST_TYPE
::
BST_TYPE
ctx_type
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Subscript
()
:
BST_expr
(
BST_TYPE
::
Subscript
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Subscript
;
};
class
BST_TryExcept
:
public
BST_stmt
{
public:
std
::
vector
<
BST_stmt
*>
body
,
orelse
;
std
::
vector
<
BST_ExceptHandler
*>
handlers
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_TryExcept
()
:
BST_stmt
(
BST_TYPE
::
TryExcept
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
TryExcept
;
};
class
BST_TryFinally
:
public
BST_stmt
{
public:
std
::
vector
<
BST_stmt
*>
body
,
finalbody
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_TryFinally
()
:
BST_stmt
(
BST_TYPE
::
TryFinally
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
TryFinally
;
};
class
BST_Tuple
:
public
BST_expr
{
public:
std
::
vector
<
BST_expr
*>
elts
;
BST_TYPE
::
BST_TYPE
ctx_type
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Tuple
()
:
BST_expr
(
BST_TYPE
::
Tuple
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Tuple
;
};
class
BST_UnaryOp
:
public
BST_expr
{
public:
BST_expr
*
operand
;
BST_TYPE
::
BST_TYPE
op_type
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_UnaryOp
()
:
BST_expr
(
BST_TYPE
::
UnaryOp
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
UnaryOp
;
};
class
BST_While
:
public
BST_stmt
{
public:
BST_expr
*
test
;
std
::
vector
<
BST_stmt
*>
body
,
orelse
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_While
()
:
BST_stmt
(
BST_TYPE
::
While
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
While
;
};
class
BST_With
:
public
BST_stmt
{
public:
BST_expr
*
optional_vars
,
*
context_expr
;
std
::
vector
<
BST_stmt
*>
body
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_With
()
:
BST_stmt
(
BST_TYPE
::
With
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
With
;
};
class
BST_Yield
:
public
BST_expr
{
public:
BST_expr
*
value
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_Yield
()
:
BST_expr
(
BST_TYPE
::
Yield
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Yield
;
};
class
BST_MakeFunction
:
public
BST_expr
{
public:
BST_FunctionDef
*
function_def
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_MakeFunction
(
BST_FunctionDef
*
fd
)
:
BST_expr
(
BST_TYPE
::
MakeFunction
,
fd
->
lineno
,
fd
->
col_offset
),
function_def
(
fd
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
MakeFunction
;
};
class
BST_MakeClass
:
public
BST_expr
{
public:
BST_ClassDef
*
class_def
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_MakeClass
(
BST_ClassDef
*
cd
)
:
BST_expr
(
BST_TYPE
::
MakeClass
,
cd
->
lineno
,
cd
->
col_offset
),
class_def
(
cd
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
MakeClass
;
};
// BST pseudo-nodes that will get added during CFG-construction. These don't exist in the input BST, but adding them in
// lets us avoid creating a completely new IR for this phase
class
CFGBlock
;
class
BST_Branch
:
public
BST_stmt
{
public:
BST_expr
*
test
;
CFGBlock
*
iftrue
,
*
iffalse
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Branch
()
:
BST_stmt
(
BST_TYPE
::
Branch
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Branch
;
};
class
BST_Jump
:
public
BST_stmt
{
public:
CFGBlock
*
target
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Jump
()
:
BST_stmt
(
BST_TYPE
::
Jump
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Jump
;
};
class
BST_ClsAttribute
:
public
BST_expr
{
public:
BST_expr
*
value
;
InternedString
attr
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_ClsAttribute
()
:
BST_expr
(
BST_TYPE
::
ClsAttribute
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
ClsAttribute
;
};
class
BST_Invoke
:
public
BST_stmt
{
public:
BST_stmt
*
stmt
;
CFGBlock
*
normal_dest
,
*
exc_dest
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
accept_stmt
(
StmtVisitor
*
v
);
BST_Invoke
(
BST_stmt
*
stmt
)
:
BST_stmt
(
BST_TYPE
::
Invoke
),
stmt
(
stmt
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
Invoke
;
};
// "LangPrimitive" represents operations that "primitive" to the language,
// but aren't directly *exactly* representable as normal Python.
// ClsAttribute would fall into this category.
// These are basically bytecodes, framed as pseudo-BST-nodes.
class
BST_LangPrimitive
:
public
BST_expr
{
public:
enum
Opcodes
{
LANDINGPAD
,
// grabs the info about the last raised exception
LOCALS
,
GET_ITER
,
IMPORT_FROM
,
IMPORT_NAME
,
IMPORT_STAR
,
NONE
,
NONZERO
,
// determines whether something is "true" for purposes of `if' and so forth
CHECK_EXC_MATCH
,
SET_EXC_INFO
,
UNCACHE_EXC_INFO
,
HASNEXT
,
PRINT_EXPR
,
}
opcode
;
std
::
vector
<
BST_expr
*>
args
;
virtual
void
accept
(
BSTVisitor
*
v
);
virtual
void
*
accept_expr
(
ExprVisitor
*
v
);
BST_LangPrimitive
(
Opcodes
opcode
)
:
BST_expr
(
BST_TYPE
::
LangPrimitive
),
opcode
(
opcode
)
{}
static
const
BST_TYPE
::
BST_TYPE
TYPE
=
BST_TYPE
::
LangPrimitive
;
};
template
<
typename
T
>
T
*
bst_cast
(
BST
*
node
)
{
ASSERT
(
!
node
||
node
->
type
==
T
::
TYPE
,
"%d"
,
node
?
node
->
type
:
0
);
return
static_cast
<
T
*>
(
node
);
}
class
BSTVisitor
{
protected:
public:
virtual
~
BSTVisitor
()
{}
virtual
bool
visit_alias
(
BST_alias
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_arguments
(
BST_arguments
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_assert
(
BST_Assert
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_assign
(
BST_Assign
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_augassign
(
BST_AugAssign
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_augbinop
(
BST_AugBinOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_attribute
(
BST_Attribute
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_binop
(
BST_BinOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_boolop
(
BST_BoolOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_break
(
BST_Break
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_call
(
BST_Call
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_clsattribute
(
BST_ClsAttribute
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_compare
(
BST_Compare
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_comprehension
(
BST_comprehension
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_classdef
(
BST_ClassDef
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_continue
(
BST_Continue
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_delete
(
BST_Delete
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_dict
(
BST_Dict
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_dictcomp
(
BST_DictComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_ellipsis
(
BST_Ellipsis
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_excepthandler
(
BST_ExceptHandler
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_exec
(
BST_Exec
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_expr
(
BST_Expr
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_expression
(
BST_Expression
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_suite
(
BST_Suite
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_extslice
(
BST_ExtSlice
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_for
(
BST_For
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_functiondef
(
BST_FunctionDef
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_generatorexp
(
BST_GeneratorExp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_global
(
BST_Global
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_if
(
BST_If
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_ifexp
(
BST_IfExp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_import
(
BST_Import
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_importfrom
(
BST_ImportFrom
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_index
(
BST_Index
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_invoke
(
BST_Invoke
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_keyword
(
BST_keyword
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_lambda
(
BST_Lambda
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_langprimitive
(
BST_LangPrimitive
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_list
(
BST_List
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_listcomp
(
BST_ListComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_module
(
BST_Module
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_name
(
BST_Name
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_num
(
BST_Num
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_pass
(
BST_Pass
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_print
(
BST_Print
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_raise
(
BST_Raise
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_repr
(
BST_Repr
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_return
(
BST_Return
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_set
(
BST_Set
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_setcomp
(
BST_SetComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_slice
(
BST_Slice
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_str
(
BST_Str
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_subscript
(
BST_Subscript
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_tryexcept
(
BST_TryExcept
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_tryfinally
(
BST_TryFinally
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_tuple
(
BST_Tuple
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_unaryop
(
BST_UnaryOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_while
(
BST_While
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_with
(
BST_With
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_yield
(
BST_Yield
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_makeclass
(
BST_MakeClass
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_makefunction
(
BST_MakeFunction
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_branch
(
BST_Branch
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
bool
visit_jump
(
BST_Jump
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
};
class
NoopBSTVisitor
:
public
BSTVisitor
{
protected:
public:
virtual
~
NoopBSTVisitor
()
{}
virtual
bool
visit_alias
(
BST_alias
*
node
)
{
return
false
;
}
virtual
bool
visit_arguments
(
BST_arguments
*
node
)
{
return
false
;
}
virtual
bool
visit_assert
(
BST_Assert
*
node
)
{
return
false
;
}
virtual
bool
visit_assign
(
BST_Assign
*
node
)
{
return
false
;
}
virtual
bool
visit_augassign
(
BST_AugAssign
*
node
)
{
return
false
;
}
virtual
bool
visit_augbinop
(
BST_AugBinOp
*
node
)
{
return
false
;
}
virtual
bool
visit_attribute
(
BST_Attribute
*
node
)
{
return
false
;
}
virtual
bool
visit_binop
(
BST_BinOp
*
node
)
{
return
false
;
}
virtual
bool
visit_boolop
(
BST_BoolOp
*
node
)
{
return
false
;
}
virtual
bool
visit_break
(
BST_Break
*
node
)
{
return
false
;
}
virtual
bool
visit_call
(
BST_Call
*
node
)
{
return
false
;
}
virtual
bool
visit_clsattribute
(
BST_ClsAttribute
*
node
)
{
return
false
;
}
virtual
bool
visit_compare
(
BST_Compare
*
node
)
{
return
false
;
}
virtual
bool
visit_comprehension
(
BST_comprehension
*
node
)
{
return
false
;
}
virtual
bool
visit_classdef
(
BST_ClassDef
*
node
)
{
return
false
;
}
virtual
bool
visit_continue
(
BST_Continue
*
node
)
{
return
false
;
}
virtual
bool
visit_delete
(
BST_Delete
*
node
)
{
return
false
;
}
virtual
bool
visit_dict
(
BST_Dict
*
node
)
{
return
false
;
}
virtual
bool
visit_dictcomp
(
BST_DictComp
*
node
)
{
return
false
;
}
virtual
bool
visit_ellipsis
(
BST_Ellipsis
*
node
)
{
return
false
;
}
virtual
bool
visit_excepthandler
(
BST_ExceptHandler
*
node
)
{
return
false
;
}
virtual
bool
visit_exec
(
BST_Exec
*
node
)
{
return
false
;
}
virtual
bool
visit_expr
(
BST_Expr
*
node
)
{
return
false
;
}
virtual
bool
visit_expression
(
BST_Expression
*
node
)
{
return
false
;
}
virtual
bool
visit_suite
(
BST_Suite
*
node
)
{
return
false
;
}
virtual
bool
visit_extslice
(
BST_ExtSlice
*
node
)
{
return
false
;
}
virtual
bool
visit_for
(
BST_For
*
node
)
{
return
false
;
}
virtual
bool
visit_functiondef
(
BST_FunctionDef
*
node
)
{
return
false
;
}
virtual
bool
visit_generatorexp
(
BST_GeneratorExp
*
node
)
{
return
false
;
}
virtual
bool
visit_global
(
BST_Global
*
node
)
{
return
false
;
}
virtual
bool
visit_if
(
BST_If
*
node
)
{
return
false
;
}
virtual
bool
visit_ifexp
(
BST_IfExp
*
node
)
{
return
false
;
}
virtual
bool
visit_import
(
BST_Import
*
node
)
{
return
false
;
}
virtual
bool
visit_importfrom
(
BST_ImportFrom
*
node
)
{
return
false
;
}
virtual
bool
visit_index
(
BST_Index
*
node
)
{
return
false
;
}
virtual
bool
visit_invoke
(
BST_Invoke
*
node
)
{
return
false
;
}
virtual
bool
visit_keyword
(
BST_keyword
*
node
)
{
return
false
;
}
virtual
bool
visit_lambda
(
BST_Lambda
*
node
)
{
return
false
;
}
virtual
bool
visit_langprimitive
(
BST_LangPrimitive
*
node
)
{
return
false
;
}
virtual
bool
visit_list
(
BST_List
*
node
)
{
return
false
;
}
virtual
bool
visit_listcomp
(
BST_ListComp
*
node
)
{
return
false
;
}
virtual
bool
visit_module
(
BST_Module
*
node
)
{
return
false
;
}
virtual
bool
visit_name
(
BST_Name
*
node
)
{
return
false
;
}
virtual
bool
visit_num
(
BST_Num
*
node
)
{
return
false
;
}
virtual
bool
visit_pass
(
BST_Pass
*
node
)
{
return
false
;
}
virtual
bool
visit_print
(
BST_Print
*
node
)
{
return
false
;
}
virtual
bool
visit_raise
(
BST_Raise
*
node
)
{
return
false
;
}
virtual
bool
visit_repr
(
BST_Repr
*
node
)
{
return
false
;
}
virtual
bool
visit_return
(
BST_Return
*
node
)
{
return
false
;
}
virtual
bool
visit_set
(
BST_Set
*
node
)
{
return
false
;
}
virtual
bool
visit_setcomp
(
BST_SetComp
*
node
)
{
return
false
;
}
virtual
bool
visit_slice
(
BST_Slice
*
node
)
{
return
false
;
}
virtual
bool
visit_str
(
BST_Str
*
node
)
{
return
false
;
}
virtual
bool
visit_subscript
(
BST_Subscript
*
node
)
{
return
false
;
}
virtual
bool
visit_tryexcept
(
BST_TryExcept
*
node
)
{
return
false
;
}
virtual
bool
visit_tryfinally
(
BST_TryFinally
*
node
)
{
return
false
;
}
virtual
bool
visit_tuple
(
BST_Tuple
*
node
)
{
return
false
;
}
virtual
bool
visit_unaryop
(
BST_UnaryOp
*
node
)
{
return
false
;
}
virtual
bool
visit_while
(
BST_While
*
node
)
{
return
false
;
}
virtual
bool
visit_with
(
BST_With
*
node
)
{
return
false
;
}
virtual
bool
visit_yield
(
BST_Yield
*
node
)
{
return
false
;
}
virtual
bool
visit_branch
(
BST_Branch
*
node
)
{
return
false
;
}
virtual
bool
visit_jump
(
BST_Jump
*
node
)
{
return
false
;
}
virtual
bool
visit_makeclass
(
BST_MakeClass
*
node
)
{
return
false
;
}
virtual
bool
visit_makefunction
(
BST_MakeFunction
*
node
)
{
return
false
;
}
};
class
ExprVisitor
{
protected:
public:
virtual
~
ExprVisitor
()
{}
virtual
void
*
visit_augbinop
(
BST_AugBinOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_attribute
(
BST_Attribute
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_binop
(
BST_BinOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_boolop
(
BST_BoolOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_call
(
BST_Call
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_clsattribute
(
BST_ClsAttribute
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_compare
(
BST_Compare
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_dict
(
BST_Dict
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_dictcomp
(
BST_DictComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_generatorexp
(
BST_GeneratorExp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_ifexp
(
BST_IfExp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_lambda
(
BST_Lambda
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_langprimitive
(
BST_LangPrimitive
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_list
(
BST_List
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_listcomp
(
BST_ListComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_name
(
BST_Name
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_num
(
BST_Num
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_repr
(
BST_Repr
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_set
(
BST_Set
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_setcomp
(
BST_SetComp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_str
(
BST_Str
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_subscript
(
BST_Subscript
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_tuple
(
BST_Tuple
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_unaryop
(
BST_UnaryOp
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_yield
(
BST_Yield
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_makeclass
(
BST_MakeClass
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_makefunction
(
BST_MakeFunction
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
};
class
StmtVisitor
{
protected:
public:
virtual
~
StmtVisitor
()
{}
virtual
void
visit_assert
(
BST_Assert
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_assign
(
BST_Assign
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_augassign
(
BST_AugAssign
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_break
(
BST_Break
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_classdef
(
BST_ClassDef
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_delete
(
BST_Delete
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_continue
(
BST_Continue
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_exec
(
BST_Exec
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_expr
(
BST_Expr
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_for
(
BST_For
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_functiondef
(
BST_FunctionDef
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_global
(
BST_Global
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_if
(
BST_If
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_import
(
BST_Import
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_importfrom
(
BST_ImportFrom
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_invoke
(
BST_Invoke
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_pass
(
BST_Pass
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_print
(
BST_Print
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_raise
(
BST_Raise
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_return
(
BST_Return
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_tryexcept
(
BST_TryExcept
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_tryfinally
(
BST_TryFinally
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_while
(
BST_While
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_with
(
BST_With
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_branch
(
BST_Branch
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
visit_jump
(
BST_Jump
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
};
class
SliceVisitor
{
public:
virtual
~
SliceVisitor
()
{}
virtual
void
*
visit_ellipsis
(
BST_Ellipsis
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_extslice
(
BST_ExtSlice
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_index
(
BST_Index
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
virtual
void
*
visit_slice
(
BST_Slice
*
node
)
{
RELEASE_ASSERT
(
0
,
""
);
}
};
void
print_bst
(
BST
*
bst
);
class
PrintVisitor
:
public
BSTVisitor
{
private:
llvm
::
raw_ostream
&
stream
;
int
indent
;
void
printIndent
();
void
printOp
(
BST_TYPE
::
BST_TYPE
op_type
);
public:
PrintVisitor
(
int
indent
=
0
,
llvm
::
raw_ostream
&
stream
=
llvm
::
outs
())
:
stream
(
stream
),
indent
(
indent
)
{}
virtual
~
PrintVisitor
()
{}
void
flush
()
{
stream
.
flush
();
}
virtual
bool
visit_alias
(
BST_alias
*
node
);
virtual
bool
visit_arguments
(
BST_arguments
*
node
);
virtual
bool
visit_assert
(
BST_Assert
*
node
);
virtual
bool
visit_assign
(
BST_Assign
*
node
);
virtual
bool
visit_augassign
(
BST_AugAssign
*
node
);
virtual
bool
visit_augbinop
(
BST_AugBinOp
*
node
);
virtual
bool
visit_attribute
(
BST_Attribute
*
node
);
virtual
bool
visit_binop
(
BST_BinOp
*
node
);
virtual
bool
visit_boolop
(
BST_BoolOp
*
node
);
virtual
bool
visit_break
(
BST_Break
*
node
);
virtual
bool
visit_call
(
BST_Call
*
node
);
virtual
bool
visit_compare
(
BST_Compare
*
node
);
virtual
bool
visit_comprehension
(
BST_comprehension
*
node
);
virtual
bool
visit_classdef
(
BST_ClassDef
*
node
);
virtual
bool
visit_clsattribute
(
BST_ClsAttribute
*
node
);
virtual
bool
visit_continue
(
BST_Continue
*
node
);
virtual
bool
visit_delete
(
BST_Delete
*
node
);
virtual
bool
visit_dict
(
BST_Dict
*
node
);
virtual
bool
visit_dictcomp
(
BST_DictComp
*
node
);
virtual
bool
visit_ellipsis
(
BST_Ellipsis
*
node
);
virtual
bool
visit_excepthandler
(
BST_ExceptHandler
*
node
);
virtual
bool
visit_exec
(
BST_Exec
*
node
);
virtual
bool
visit_expr
(
BST_Expr
*
node
);
virtual
bool
visit_expression
(
BST_Expression
*
node
);
virtual
bool
visit_suite
(
BST_Suite
*
node
);
virtual
bool
visit_extslice
(
BST_ExtSlice
*
node
);
virtual
bool
visit_for
(
BST_For
*
node
);
virtual
bool
visit_functiondef
(
BST_FunctionDef
*
node
);
virtual
bool
visit_generatorexp
(
BST_GeneratorExp
*
node
);
virtual
bool
visit_global
(
BST_Global
*
node
);
virtual
bool
visit_if
(
BST_If
*
node
);
virtual
bool
visit_ifexp
(
BST_IfExp
*
node
);
virtual
bool
visit_import
(
BST_Import
*
node
);
virtual
bool
visit_importfrom
(
BST_ImportFrom
*
node
);
virtual
bool
visit_index
(
BST_Index
*
node
);
virtual
bool
visit_invoke
(
BST_Invoke
*
node
);
virtual
bool
visit_keyword
(
BST_keyword
*
node
);
virtual
bool
visit_lambda
(
BST_Lambda
*
node
);
virtual
bool
visit_langprimitive
(
BST_LangPrimitive
*
node
);
virtual
bool
visit_list
(
BST_List
*
node
);
virtual
bool
visit_listcomp
(
BST_ListComp
*
node
);
virtual
bool
visit_module
(
BST_Module
*
node
);
virtual
bool
visit_name
(
BST_Name
*
node
);
virtual
bool
visit_num
(
BST_Num
*
node
);
virtual
bool
visit_pass
(
BST_Pass
*
node
);
virtual
bool
visit_print
(
BST_Print
*
node
);
virtual
bool
visit_raise
(
BST_Raise
*
node
);
virtual
bool
visit_repr
(
BST_Repr
*
node
);
virtual
bool
visit_return
(
BST_Return
*
node
);
virtual
bool
visit_set
(
BST_Set
*
node
);
virtual
bool
visit_setcomp
(
BST_SetComp
*
node
);
virtual
bool
visit_slice
(
BST_Slice
*
node
);
virtual
bool
visit_str
(
BST_Str
*
node
);
virtual
bool
visit_subscript
(
BST_Subscript
*
node
);
virtual
bool
visit_tuple
(
BST_Tuple
*
node
);
virtual
bool
visit_tryexcept
(
BST_TryExcept
*
node
);
virtual
bool
visit_tryfinally
(
BST_TryFinally
*
node
);
virtual
bool
visit_unaryop
(
BST_UnaryOp
*
node
);
virtual
bool
visit_while
(
BST_While
*
node
);
virtual
bool
visit_with
(
BST_With
*
node
);
virtual
bool
visit_yield
(
BST_Yield
*
node
);
virtual
bool
visit_branch
(
BST_Branch
*
node
);
virtual
bool
visit_jump
(
BST_Jump
*
node
);
virtual
bool
visit_makefunction
(
BST_MakeFunction
*
node
);
virtual
bool
visit_makeclass
(
BST_MakeClass
*
node
);
};
};
#endif
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment