@@ -350,12 +350,12 @@ enum {
350
350
typedef struct cfg_builder_ {
351
351
/* The entryblock, at which control flow begins. All blocks of the
352
352
CFG are reachable through the b_next links */
353
- basicblock * cfg_entryblock ;
353
+ basicblock * g_entryblock ;
354
354
/* Pointer to the most recently allocated block. By following
355
355
b_list links, you can reach all allocated blocks. */
356
- basicblock * block_list ;
356
+ basicblock * g_block_list ;
357
357
/* pointer to the block currently being constructed */
358
- basicblock * curblock ;
358
+ basicblock * g_curblock ;
359
359
/* label for the next instruction to be placed */
360
360
jump_target_label g_current_label ;
361
361
/* next free label id */
@@ -751,7 +751,7 @@ dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)
751
751
static void
752
752
cfg_builder_check (cfg_builder * g )
753
753
{
754
- for (basicblock * block = g -> block_list ; block != NULL ; block = block -> b_list ) {
754
+ for (basicblock * block = g -> g_block_list ; block != NULL ; block = block -> b_list ) {
755
755
assert (!_PyMem_IsPtrFreed (block ));
756
756
if (block -> b_instr != NULL ) {
757
757
assert (block -> b_ialloc > 0 );
@@ -769,7 +769,7 @@ static void
769
769
cfg_builder_free (cfg_builder * g )
770
770
{
771
771
cfg_builder_check (g );
772
- basicblock * b = g -> block_list ;
772
+ basicblock * b = g -> g_block_list ;
773
773
while (b != NULL ) {
774
774
if (b -> b_instr ) {
775
775
PyObject_Free ((void * )b -> b_instr );
@@ -884,8 +884,8 @@ cfg_builder_new_block(cfg_builder *g)
884
884
return NULL ;
885
885
}
886
886
/* Extend the singly linked list of blocks with new block. */
887
- b -> b_list = g -> block_list ;
888
- g -> block_list = b ;
887
+ b -> b_list = g -> g_block_list ;
888
+ g -> g_block_list = b ;
889
889
b -> b_label = -1 ;
890
890
return b ;
891
891
}
@@ -894,8 +894,8 @@ static basicblock *
894
894
cfg_builder_use_next_block (cfg_builder * g , basicblock * block )
895
895
{
896
896
assert (block != NULL );
897
- g -> curblock -> b_next = block ;
898
- g -> curblock = block ;
897
+ g -> g_curblock -> b_next = block ;
898
+ g -> g_curblock = block ;
899
899
return block ;
900
900
}
901
901
@@ -1313,7 +1313,7 @@ cfg_builder_current_block_is_terminated(cfg_builder *g)
1313
1313
if (IS_LABEL (g -> g_current_label )) {
1314
1314
return true;
1315
1315
}
1316
- struct instr * last = basicblock_last_instr (g -> curblock );
1316
+ struct instr * last = basicblock_last_instr (g -> g_curblock );
1317
1317
return last && IS_TERMINATOR_OPCODE (last -> i_opcode );
1318
1318
}
1319
1319
@@ -1339,7 +1339,7 @@ cfg_builder_addop(cfg_builder *g, int opcode, int oparg, jump_target_label targe
1339
1339
if (cfg_builder_maybe_start_new_block (g ) != 0 ) {
1340
1340
return -1 ;
1341
1341
}
1342
- return basicblock_addop (g -> curblock , opcode , oparg , target , loc );
1342
+ return basicblock_addop (g -> g_curblock , opcode , oparg , target , loc );
1343
1343
}
1344
1344
1345
1345
static int
@@ -1788,11 +1788,11 @@ compiler_enter_scope(struct compiler *c, identifier name,
1788
1788
c -> c_nestlevel ++ ;
1789
1789
1790
1790
cfg_builder * g = CFG_BUILDER (c );
1791
- g -> block_list = NULL ;
1791
+ g -> g_block_list = NULL ;
1792
1792
block = cfg_builder_new_block (g );
1793
1793
if (block == NULL )
1794
1794
return 0 ;
1795
- g -> curblock = g -> cfg_entryblock = block ;
1795
+ g -> g_curblock = g -> g_entryblock = block ;
1796
1796
g -> g_current_label = NO_LABEL ;
1797
1797
1798
1798
if (u -> u_scope_type == COMPILER_SCOPE_MODULE ) {
@@ -7386,7 +7386,7 @@ mark_cold(basicblock *entryblock) {
7386
7386
7387
7387
static int
7388
7388
push_cold_blocks_to_end (cfg_builder * g , int code_flags ) {
7389
- basicblock * entryblock = g -> cfg_entryblock ;
7389
+ basicblock * entryblock = g -> g_entryblock ;
7390
7390
if (entryblock -> b_next == NULL ) {
7391
7391
/* single basicblock, no need to reorder */
7392
7392
return 0 ;
@@ -8516,7 +8516,7 @@ assemble(struct compiler *c, int addNone)
8516
8516
}
8517
8517
8518
8518
/* Make sure every block that falls off the end returns None. */
8519
- if (!basicblock_returns (CFG_BUILDER (c )-> curblock )) {
8519
+ if (!basicblock_returns (CFG_BUILDER (c )-> g_curblock )) {
8520
8520
UNSET_LOC (c );
8521
8521
if (addNone )
8522
8522
ADDOP_LOAD_CONST (c , Py_None );
@@ -8538,7 +8538,7 @@ assemble(struct compiler *c, int addNone)
8538
8538
}
8539
8539
8540
8540
int nblocks = 0 ;
8541
- for (basicblock * b = CFG_BUILDER (c )-> block_list ; b != NULL ; b = b -> b_list ) {
8541
+ for (basicblock * b = CFG_BUILDER (c )-> g_block_list ; b != NULL ; b = b -> b_list ) {
8542
8542
nblocks ++ ;
8543
8543
}
8544
8544
if ((size_t )nblocks > SIZE_MAX / sizeof (basicblock * )) {
@@ -8547,7 +8547,7 @@ assemble(struct compiler *c, int addNone)
8547
8547
}
8548
8548
8549
8549
cfg_builder * g = CFG_BUILDER (c );
8550
- basicblock * entryblock = g -> cfg_entryblock ;
8550
+ basicblock * entryblock = g -> g_entryblock ;
8551
8551
assert (entryblock != NULL );
8552
8552
8553
8553
/* Set firstlineno if it wasn't explicitly set. */
@@ -9569,7 +9569,7 @@ duplicate_exits_without_lineno(cfg_builder *g)
9569
9569
{
9570
9570
/* Copy all exit blocks without line number that are targets of a jump.
9571
9571
*/
9572
- basicblock * entryblock = g -> cfg_entryblock ;
9572
+ basicblock * entryblock = g -> g_entryblock ;
9573
9573
for (basicblock * b = entryblock ; b != NULL ; b = b -> b_next ) {
9574
9574
if (b -> b_iused > 0 && is_jump (& b -> b_instr [b -> b_iused - 1 ])) {
9575
9575
basicblock * target = b -> b_instr [b -> b_iused - 1 ].i_target ;
0 commit comments