void GoRegionBoard::RemoveBlock(GoBlock* b, bool isExecute,
bool removeFromRegions)
{
SgBlackWhite color = b->Color();
for (SgSetIterator it(b->Stones()); it; ++it)
m_block[*it] = 0;
bool found = m_allBlocks[color].Exclude(b);
SG_UNUSED(found);
SG_ASSERT(found);
const int size = Board().Size();
// remove from regions.
SgPointSet area(b->Stones().Border(size));
SgVectorOf<GoRegion> regions;
if (removeFromRegions)
{
RegionsAt(area, color, ®ions);
for (SgVectorIteratorOf<GoRegion> it(regions); it; ++it)
{
(*it)->RemoveBlock(b);
if (isExecute)
m_stack.PushPtr(*it);
}
}
if (isExecute)
{
m_stack.PushInt(regions.Length()); // 0 if ! removeFromRegions
PushBlock(REGION_REMOVE_BLOCK, b);
}
else
delete b;
}
/* ParseFor - parse the 'FOR' statement */
static void ParseFor(ParseContext *c)
{
ParseTreeNode *var, *step;
int test, body, inst;
Token tkn;
PVAL pv;
PushBlock(c);
c->bptr->type = BLOCK_FOR;
/* get the control variable */
FRequire(c, T_IDENTIFIER);
var = GetSymbolRef(c, c->token);
code_lvalue(c, var, &pv);
FRequire(c, '=');
/* parse the starting value expression */
ParseRValue(c);
/* parse the TO expression and generate the loop termination test */
test = codeaddr(c);
(*pv.fcn)(c, PV_STORE, &pv);
(*pv.fcn)(c, PV_LOAD, &pv);
FRequire(c, T_TO);
ParseRValue(c);
putcbyte(c, OP_LE);
putcbyte(c, OP_BRT);
body = putcword(c, 0);
/* branch to the end if the termination test fails */
putcbyte(c, OP_BR);
c->bptr->u.ForBlock.end = putcword(c, 0);
/* update the for variable after an iteration of the loop */
c->bptr->u.ForBlock.nxt = codeaddr(c);
(*pv.fcn)(c, PV_LOAD, &pv);
/* get the STEP expression */
if ((tkn = GetToken(c)) == T_STEP) {
step = ParseExpr(c);
code_rvalue(c, step);
tkn = GetToken(c);
}
/* no step so default to one */
else {
putcbyte(c, OP_LIT);
putcword(c, 1);
}
/* generate the increment code */
putcbyte(c, OP_ADD);
inst = putcbyte(c, OP_BR);
putcword(c, test - inst - 1 - sizeof(VMUVALUE));
/* branch to the loop body */
fixupbranch(c, body, codeaddr(c));
Require(c, tkn, T_EOL);
}
/* ParseDo - parse the 'DO' statement */
static void ParseDo(ParseContext *c)
{
PushBlock(c);
c->bptr->type = BLOCK_DO;
c->bptr->u.DoBlock.nxt = codeaddr(c);
c->bptr->u.DoBlock.end = 0;
FRequire(c, T_EOL);
}
void GoRegionBoard::AddBlock(GoBlock* b, bool isExecute)
{
SgBlackWhite color = b->Color();
AllBlocks(color).PushBack(b);
for (GoBoard::StoneIterator it(Board(), b->Anchor()); it; ++it)
m_block[*it] = b;
if (isExecute)
PushBlock(REGION_ADD_BLOCK, b);
}
/* ParseDoUntil - parse the 'DO UNTIL' statement */
static void ParseDoUntil(ParseContext *c)
{
PushBlock(c);
c->bptr->type = BLOCK_DO;
c->bptr->u.DoBlock.nxt = codeaddr(c);
ParseRValue(c);
putcbyte(c, OP_BRT);
c->bptr->u.DoBlock.end = putcword(c, 0);
FRequire(c, T_EOL);
}
static void ForStmt( void )
{
bool parsed_semi_colon = FALSE;
NextToken();
MustRecog( T_LEFT_PAREN );
if( CompFlags.c99_extensions ) {
PushBlock(); // 'for' opens new scope
}
if( CurToken != T_SEMI_COLON ) {
if( CompFlags.c99_extensions ) {
TREEPTR tree;
tree = LeafNode( OPR_NEWBLOCK );
AddStmt( tree );
BlockStack->gen_endblock = TRUE;
if( !LoopDecl( &BlockStack->sym_list ) ) {
ChkStmtExpr(); // no declarator, try init_expr
} else {
parsed_semi_colon = TRUE; // LoopDecl ate it up
}
tree->op.sym_handle = BlockStack->sym_list;
} else {
ChkStmtExpr(); // init_expr
}
}
if( !parsed_semi_colon ) {
MustRecog( T_SEMI_COLON );
}
NewLoop();
BlockStack->block_type = T_FOR;
if( CurToken != T_SEMI_COLON ) {
BlockStack->break_label = NextLabel();
if( !JumpFalse( Expr(), BlockStack->break_label ) ) {
BlockStack->break_label = 0; /* 09-sep-92 */
}
}
MustRecog( T_SEMI_COLON );
BlockStack->inc_var = NULL;
if( CurToken != T_RIGHT_PAREN ) {
BlockStack->inc_var = Expr(); // save this
if( CompFlags.meaningless_stmt == 1 ) {
ChkUseful();
}
}
MustRecog( T_RIGHT_PAREN );
}
/* ParseIf - parse the 'IF' statement */
static void ParseIf(ParseContext *c)
{
Token tkn;
ParseRValue(c);
FRequire(c, T_THEN);
PushBlock(c);
c->bptr->type = BLOCK_IF;
putcbyte(c, OP_BRF);
c->bptr->u.IfBlock.nxt = putcword(c, 0);
c->bptr->u.IfBlock.end = 0;
if ((tkn = GetToken(c)) != T_EOL) {
ParseStatement(c, tkn);
fixupbranch(c, c->bptr->u.IfBlock.nxt, codeaddr(c));
PopBlock(c);
}
else
Require(c, tkn, T_EOL);
}
