boolean findEOPD_impl(bitset currentEopdVertices, bitset currentEopdFaces, int eopdExtension, bitset remainingFaces, EDGE *lastExtendedEdge){ //first check whether this is a covering eOPD if(IS_NOT_EMPTY(INTERSECTION(currentEopdFaces, remainingFaces))){ printFaceTupleFaces(currentEopdFaces); return TRUE; } //otherwise try extending the eOPD EDGE *extension = lastExtendedEdge->next; if(INTERSECTION(currentEopdVertices, neighbourhood[extension->next->end]) == extension->vertices){ //face to the right of extension is addable if(findEOPD_impl(UNION(currentEopdVertices, faceSets[extension->rightface]), UNION(currentEopdFaces, SINGLETON(extension->rightface)), eopdExtension, remainingFaces, extension)){ return TRUE; } } extension = lastExtendedEdge->inverse->prev->inverse; if(INTERSECTION(currentEopdVertices, neighbourhood[extension->next->end]) == extension->vertices){ //face to the right of extension is addable if(findEOPD_impl(UNION(currentEopdVertices, faceSets[extension->rightface]), UNION(currentEopdFaces, SINGLETON(extension->rightface)), eopdExtension, remainingFaces, extension)){ return TRUE; } } return FALSE; }
static void solve() { int i, j, k, a, b; for (i = 0; i < n; i++) { for (k = (i << 7), j = 0; j < m; j++, k++) { pred[k] = k; count[k] = 1; } } for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { if (map[i][j] != 'W') continue; k = (i << 7) + j; for (a = k; pred[a] != a; a = pred[a]); pred[k] = a; #define UNION(by, bx) { \ k = ((by) << 7) + (bx); \ for (b = k; pred[b] != b; b = pred[b]); \ pred[k] = b; \ if (a != b) { \ if (count[a] > count[b]) { \ count[a] += count[b]; \ pred[b] = a; \ } else { \ count[b] += count[a]; \ a = pred[a] = b; \ } \ } \ } if (i > 0) { if (j > 0 && map[i - 1][j - 1] == 'W') UNION(i - 1, j - 1); if (map[i - 1][j] == 'W') UNION(i - 1, j); if ((j + 1) < m && map[i - 1][j + 1] == 'W') UNION(i - 1, j + 1); } if (j > 0 && map[i][j - 1] == 'W') { UNION(i, j - 1); } } } }
boolean findEOPD(bitset tuple){ int i, j; //first we check the stored OPD's for(i = 0; i < eopdCount; i++){ bitset intersectionOpd = INTERSECTION(tuple, opdFaces[i]); bitset intersectionExtensions = INTERSECTION(tuple, extensionFaces[i]); if((IS_NOT_EMPTY(intersectionOpd) && IS_NOT_EMPTY(intersectionExtensions)) || (HAS_MORE_THAN_ONE_ELEMENT(intersectionOpd))){ numberOfTuplesCoveredByStoredOpd++; return TRUE; } } //then we try to find a new eOPD for(i = 0; i < nf; i++){ if(CONTAINS(tuple, i)){ //try to find a eOPD with face i as extension bitset remainingFaces = MINUS(tuple, i); //we use each edge once as a possible shared edge EDGE *sharedEdge = facestart[i]; for(j = 0; j < 3; j++){ //construct initial eopd int neighbouringFace = sharedEdge->inverse->rightface; bitset currentEopdVertices = faceSets[neighbouringFace]; bitset currentEopdFaces = UNION(SINGLETON(i), SINGLETON(neighbouringFace)); if(findEOPD_impl(currentEopdVertices, currentEopdFaces, i, remainingFaces, sharedEdge->inverse)){ return TRUE; } sharedEdge = sharedEdge->next->inverse; } } } return FALSE; }
int main() { int i; char s[10]; int x, y; scanf("%d", &t); while (t--) { scanf("%d%d", &n, &m); for (i = 1; i <= n; i++) { f[i] = -1; r[i] = 1; } while (m--) { scanf("%s%d%d", s, &x, &y); if (s[0] == 'A') { if (FIND(x) == FIND(y)) { if (r[x] == r[y]) printf("In the same gang.\n"); else printf("In different gangs.\n"); } else printf("Not sure yet.\n"); } if (s[0] == 'D') UNION(x, y); } } return 0; }
void operator()(const PRIMITIVES& _in, PRIMITIVES& _out) { typedef typename PRIMITIVES::value_type primitive_type; std::list<primitive_type> _input; for (auto& p : _in ) _input.push_back(p); for (auto i = _input.begin(); i != _input.end(); ++i) { auto j = i; ++j; for (; j != _input.end(); ++j) { if (!intersects(i->bounds(),j->bounds())) continue; PRIMITIVES _newPrimitives; UNION()(*i,*j,_newPrimitives); if (_newPrimitives.size() == 1) { _newPrimitives.back().update(); *i = _newPrimitives.back(); _input.erase(j); j = i; } } } _out.insert(_out.end(),_input.begin(),_input.end()); }
int main() { int i, j, x, y, ans; scanf("%d", &t); for (i = 1; i <= t; i++) { scanf("%d %d", &n, &m); for (j = 1; j <= n; j++) { f[j] = -1; r[j] = 1; } ans = 0; while (m--) { scanf("%d %d", &x, &y); if (FIND(x) == FIND(y)) { if (r[x] == r[y]) ans = 1; } else UNION(x, y); } printf("Scenario #%d:\n", i); if (ans) printf("Suspicious bugs found!\n\n"); else printf("No suspicious bugs found!\n\n"); } return 0; }
void kruskal() { NODE *u, *v; SET *uSet, *vSet; for( ADJ_LIST *header = adjListBeg; header != NULL; header = header->down) { u = header->node; makeSet(u); } sortEdges(); for( int i = 0; i < edgeCount; i++ ) { uSet = findSet(edgeList[i].node1); vSet = findSet(edgeList[i].node2); if( uSet != vSet ) { cout << "Taking edge : " << edgeList[i].node1->id << "--" << edgeList[i].node2->id << ":" << edgeList[i].weight << endl; UNION(uSet, vSet); changeEdgeColor(&edgeList[i], GREEN); sleep(1); changeNodeColor(edgeList[i].node1, GREEN); usleep(500000); changeNodeColor(edgeList[i].node2, GREEN); sleep(1); } } }
int main() { int i, d, x, y, ans; scanf("%d %d", &n, &k); for (i = 1; i <= n; i++) { f[i] = -1; r[i] = 0; } ans = 0; for (i = 0; i < k; i++) { scanf("%d %d %d", &d, &x, &y); if (x > n || y > n || d == 2 && x == y) { ans++; continue; } ans += UNION(x, y, d); } printf("%d\n", ans); return 0; }
static void check_bool2_init (enum tree_code code, tree exp0, tree exp1, words before, words when_false, words when_true) { word buf[2*4]; words tmp = num_current_words <= 2 ? buf : ALLOC_WORDS (4 * num_current_words); words when_false_0 = tmp; words when_false_1 = tmp+num_current_words; words when_true_0 = tmp+2*num_current_words; words when_true_1 = tmp+3*num_current_words; check_bool_init (exp0, before, when_false_0, when_true_0); INTERSECT (before, when_false_0, when_true_0); check_bool_init (exp1, before, when_false_1, when_true_1); INTERSECT (before, when_false_1, when_true_1); if (code == EQ_EXPR) { /* Now set: * when_true = (when_false_1 INTERSECTION when_true_1) * UNION (when_true_0 INTERSECTION when_false_1) * UNION (when_false_0 INTERSECTION when_true_1); * using when_false and before as temporary working areas. */ INTERSECT (when_true, when_true_0, when_false_1); INTERSECT (when_false, when_true_0, when_false_1); UNION (when_true, when_true, when_false); UNION (when_true, when_true, before); /* Now set: * when_false = (when_false_1 INTERSECTION when_true_1) * UNION (when_true_0 INTERSECTION when_true_1) * UNION (when_false_0 INTERSECTION when_false_1); * using before as a temporary working area. */ INTERSECT (when_false, when_true_0, when_true_1); UNION (when_false, when_false, before); INTERSECT (before, when_false_0, when_false_1); UNION (when_false, when_false, before); } else if (code == BIT_AND_EXPR || code == TRUTH_AND_EXPR) { UNION (when_true, when_true_0, when_true_1); INTERSECT (when_false, when_false_0, when_false_1); UNION (when_false, when_false, before); } else /* if (code == BIT_IOR_EXPR || code == TRUTH_OR_EXPR) */ { UNION (when_false, when_false_0, when_false_1); INTERSECT (when_true, when_true_0, when_true_1); UNION (when_true, when_true, before); } if (tmp != buf) FREE_WORDS (tmp); }
boolean findUncoveredFaceTuple_impl(bitset tuple, bitset tupleVertices, int position, int size){ if(size + (nf - position) < 4){ //this tuple can't be completed to a 4-tuple return FALSE; } if(size < 3){ //just extend and continue int i; for(i = position; i < nf - 3 + size; i++){ if(IS_EMPTY(INTERSECTION(tupleVertices, faceSets[i]))){ if(findUncoveredFaceTuple_impl(UNION(tuple, SINGLETON(i)), UNION(tupleVertices, faceSets[i]), i+1, size+1)){ return TRUE; } } } } else if(size == 3){ //search for eOPD and if none found: go to 4-tuple numberOfChecked3Tuples++; if(findEOPD(tuple)){ return FALSE; } //no eOPD found: extending tuple int i; for(i = position; i < nf; i++){ if(IS_EMPTY(INTERSECTION(tupleVertices, faceSets[i]))){ if(findUncoveredFaceTuple_impl(UNION(tuple, SINGLETON(i)), UNION(tupleVertices, faceSets[i]), i+1, size+1)){ return TRUE; } } } } else {// size == 4 numberOfChecked4Tuples++; //search for eOPD return !findEOPD(tuple); } //if we get here then all tuples extending the current tuple were covered return FALSE; }
void constructInitialEopds(){ int i; greedyExtendOpdAndStore(faceSets[0], SINGLETON(0)); bitset coveredFaces = UNION(opdFaces[eopdCount-1], extensionFaces[eopdCount-1]); for(i = nf -1; i > 0; i--){ if(!CONTAINS(coveredFaces, i)){ greedyExtendOpdAndStore(faceSets[i], SINGLETON(i)); ADD_ALL(coveredFaces, opdFaces[eopdCount-1]); ADD_ALL(coveredFaces, extensionFaces[eopdCount-1]); } } }
boolean findEOPD(bitset tuple){ int i, j; for(i = 0; i < nf; i++){ if(CONTAINS(tuple, i)){ //try to find a eOPD with face i as extension bitset remainingFaces = MINUS(tuple, i); //we use each edge once as a possible shared edge EDGE *sharedEdge = facestart[i]; for(j = 0; j < 3; j++){ //construct initial eopd int neighbouringFace = sharedEdge->inverse->rightface; bitset currentEopdVertices = faceSets[neighbouringFace]; bitset currentEopdFaces = UNION(SINGLETON(i), SINGLETON(neighbouringFace)); if(findEOPD_impl(currentEopdVertices, currentEopdFaces, i, remainingFaces, sharedEdge->inverse)){ return TRUE; } sharedEdge = sharedEdge->next->inverse; } } } return FALSE; }
Clusters *Merge_Segments(Segmentation *segs, Overlaps *ovl) { Clusters *clust; int *fathers, *sets, *which; int nsegs, nsets; int j, k; nsegs = ovl->totsegs; which = (int *) Guarded_Malloc(sizeof(int)*(2*nsegs+1),Program_Name()); sets = which + nsegs; fathers = (int *) Guarded_Malloc(sizeof(int)*nsegs,Program_Name()); for (k = 0; k < nsegs; k++) fathers[k] = -1; for (k = 0; k < nsegs; k++) for (j = ovl->alist[k]; j < ovl->alist[k+1]; j++) UNION(fathers,k,ovl->heads[j]); nsets = 0; for (k = 0; k < nsegs; k++) if (fathers[k] < 0) { nsets += 1; fathers[k] = -nsets; } else fathers[k] = FIND(fathers,k); for (k = 0; k < nsegs; k++) if (fathers[k] > 0) fathers[k] = fathers[fathers[k]]; for (k = 0; k < nsegs; k++) fathers[k] = -(fathers[k]+1); for (k = 0; k <= nsets; k++) sets[k] = 0; for (k = 0; k < nsegs; k++) sets[fathers[k]+1] += 1; for (k = 2; k <= nsets; k++) sets[k] += sets[k-1]; for (k = 0; k < nsegs; k++) { which[sets[fathers[k]]] = k; sets[fathers[k]] += 1; } for (k = nsegs; k > 0; k--) sets[k] = sets[k-1]; sets[0] = 0; free(fathers); clust = (Clusters *) Guarded_Malloc(sizeof(Clusters),Program_Name()); clust->inum = nsets; clust->ilist = sets; clust->item = which; #ifdef VERBOSE printf("\nClusters:\n"); for (k = 0; k < nsets; k++) { printf(" Set %3d:",k); for (j = sets[k]; j < sets[k+1]; j++) { int c = ovl->chans[which[j]]; printf(" %c%d",Letter[c],(which[j]-segs[c].base)+1); } printf("\n"); fflush(stdout); } fflush(stdout); #endif return (clust); }
void decodePlanarCode(unsigned short* code) { /* complexity of method to determine inverse isn't that good, but will have to satisfy for now */ int i, j, codePosition; int edgeCounter = 0; EDGE *inverse; nv = code[0]; codePosition = 1; for (i = 0; i < nv; i++) { degree[i] = 0; neighbourhood[i] = SINGLETON(code[codePosition] - 1); firstedge[i] = edges + edgeCounter; edges[edgeCounter].start = i; edges[edgeCounter].end = code[codePosition] - 1; edges[edgeCounter].vertices = UNION(SINGLETON(i), SINGLETON(code[codePosition] - 1)); edges[edgeCounter].next = edges + edgeCounter + 1; if (code[codePosition] - 1 < i) { inverse = edgeMatrix[code[codePosition] - 1][i]; edges[edgeCounter].inverse = inverse; inverse->inverse = edges + edgeCounter; } else { edgeMatrix[i][code[codePosition] - 1] = edges + edgeCounter; edges[edgeCounter].inverse = NULL; } edgeCounter++; codePosition++; for (j = 1; code[codePosition]; j++, codePosition++) { if (j == MAXVAL) { fprintf(stderr, "MAXVAL too small: %d\n", MAXVAL); exit(0); } ADD(neighbourhood[i], code[codePosition] - 1); edges[edgeCounter].start = i; edges[edgeCounter].end = code[codePosition] - 1; edges[edgeCounter].vertices = UNION(SINGLETON(i), SINGLETON(code[codePosition] - 1)); edges[edgeCounter].prev = edges + edgeCounter - 1; edges[edgeCounter].next = edges + edgeCounter + 1; if (code[codePosition] - 1 < i) { inverse = edgeMatrix[code[codePosition] - 1][i]; edges[edgeCounter].inverse = inverse; inverse->inverse = edges + edgeCounter; } else { edgeMatrix[i][code[codePosition] - 1] = edges + edgeCounter; edges[edgeCounter].inverse = NULL; } edgeCounter++; } firstedge[i]->prev = edges + edgeCounter - 1; edges[edgeCounter - 1].next = firstedge[i]; degree[i] = j; codePosition++; /* read the closing 0 */ } ne = edgeCounter; makeDual(); // nv - ne/2 + nf = 2 }
static void check_init (tree exp, words before) { tree tmp; again: switch (TREE_CODE (exp)) { case VAR_DECL: case PARM_DECL: if (! FIELD_STATIC (exp) && DECL_NAME (exp) != NULL_TREE && DECL_NAME (exp) != this_identifier_node) { int index = DECL_BIT_INDEX (exp); /* We don't want to report and mark as non-initialized class initialization flags. */ if (! LOCAL_CLASS_INITIALIZATION_FLAG_P (exp) && index >= 0 && ! ASSIGNED_P (before, index)) { parse_error_context (wfl, "Variable %qs may not have been initialized", IDENTIFIER_POINTER (DECL_NAME (exp))); /* Suppress further errors. */ DECL_BIT_INDEX (exp) = -2; } } break; case COMPONENT_REF: check_init (TREE_OPERAND (exp, 0), before); if ((tmp = get_variable_decl (exp)) != NULL_TREE) { int index = DECL_BIT_INDEX (tmp); if (index >= 0 && ! ASSIGNED_P (before, index)) { parse_error_context (wfl, "variable %qs may not have been initialized", IDENTIFIER_POINTER (DECL_NAME (tmp))); /* Suppress further errors. */ DECL_BIT_INDEX (tmp) = -2; } } break; case MODIFY_EXPR: tmp = TREE_OPERAND (exp, 0); /* We're interested in variable declaration and parameter declaration when they're declared with the `final' modifier. */ if ((tmp = get_variable_decl (tmp)) != NULL_TREE) { int index; check_init (TREE_OPERAND (exp, 1), before); check_final_reassigned (tmp, before); index = DECL_BIT_INDEX (tmp); if (index >= 0) { SET_ASSIGNED (before, index); CLEAR_UNASSIGNED (before, index); } /* Minor optimization. See comment for start_current_locals. If we're optimizing for class initialization, we keep this information to check whether the variable is definitely assigned when once we checked the whole function. */ if (! STATIC_CLASS_INIT_OPT_P () /* FIXME */ && ! DECL_FINAL (tmp) && index >= start_current_locals && index == num_current_locals - 1) { num_current_locals--; DECL_BIT_INDEX (tmp) = -1; } break; } else if (TREE_CODE (tmp = TREE_OPERAND (exp, 0)) == COMPONENT_REF) { tree decl; check_init (tmp, before); check_init (TREE_OPERAND (exp, 1), before); decl = TREE_OPERAND (tmp, 1); if (DECL_FINAL (decl)) final_assign_error (DECL_NAME (decl)); break; } else if (TREE_CODE (tmp) == COMPONENT_REF && IS_ARRAY_LENGTH_ACCESS (tmp)) { /* We can't emit a more specific message here, because when compiling to bytecodes we don't get here. */ final_assign_error (length_identifier_node); } else goto binop; case BLOCK: if (BLOCK_EXPR_BODY (exp)) { tree decl = BLOCK_EXPR_DECLS (exp); int words_needed; word* tmp; int i; int save_start_current_locals = start_current_locals; int save_num_current_words = num_current_words; start_current_locals = num_current_locals; for (; decl != NULL_TREE; decl = TREE_CHAIN (decl)) { DECL_BIT_INDEX (decl) = num_current_locals++; } words_needed = WORDS_NEEDED (2 * num_current_locals); if (words_needed > num_current_words) { tmp = ALLOC_WORDS (words_needed); COPY (tmp, before); num_current_words = words_needed; } else tmp = before; for (i = start_current_locals; i < num_current_locals; i++) { CLEAR_ASSIGNED (tmp, i); SET_UNASSIGNED (tmp, i); } check_init (BLOCK_EXPR_BODY (exp), tmp); /* Re-set DECL_BIT_INDEX since it is also DECL_POINTER_ALIAS_SET. */ for (decl = BLOCK_EXPR_DECLS (exp); decl != NULL_TREE; decl = TREE_CHAIN (decl)) { if (LOCAL_CLASS_INITIALIZATION_FLAG_P (decl)) { int index = DECL_BIT_INDEX (decl); tree fndecl = DECL_CONTEXT (decl); if (fndecl && METHOD_STATIC (fndecl) && (DECL_INITIAL (decl) == boolean_true_node || (index >= 0 && ASSIGNED_P (tmp, index)))) *(htab_find_slot (DECL_FUNCTION_INITIALIZED_CLASS_TABLE (fndecl), DECL_FUNCTION_INIT_TEST_CLASS (decl), INSERT)) = DECL_FUNCTION_INIT_TEST_CLASS (decl); } DECL_BIT_INDEX (decl) = -1; } num_current_locals = start_current_locals; start_current_locals = save_start_current_locals; if (tmp != before) { num_current_words = save_num_current_words; COPY (before, tmp); FREE_WORDS (tmp); } } break; case LOOP_EXPR: { /* The JLS 2nd edition discusses a complication determining definite unassignment of loop statements. They define a "hypothetical" analysis model. We do something much simpler: We just disallow assignments inside loops to final variables declared outside the loop. This means we may disallow some contrived assignments that the JLS allows, but I can't see how anything except a very contrived testcase (a do-while whose condition is false?) would care. */ struct alternatives alt; int save_loop_current_locals = loop_current_locals; int save_start_current_locals = start_current_locals; loop_current_locals = num_current_locals; start_current_locals = num_current_locals; BEGIN_ALTERNATIVES (before, alt); alt.block = exp; check_init (TREE_OPERAND (exp, 0), before); END_ALTERNATIVES (before, alt); loop_current_locals = save_loop_current_locals; start_current_locals = save_start_current_locals; return; } case EXIT_EXPR: { struct alternatives *alt = alternatives; DECLARE_BUFFERS(when_true, 2); words when_false = when_true + num_current_words; #ifdef ENABLE_JC1_CHECKING if (TREE_CODE (alt->block) != LOOP_EXPR) abort (); #endif check_bool_init (TREE_OPERAND (exp, 0), before, when_false, when_true); done_alternative (when_true, alt); COPY (before, when_false); RELEASE_BUFFERS(when_true); return; } case LABELED_BLOCK_EXPR: { struct alternatives alt; BEGIN_ALTERNATIVES (before, alt); alt.block = exp; if (LABELED_BLOCK_BODY (exp)) check_init (LABELED_BLOCK_BODY (exp), before); done_alternative (before, &alt); END_ALTERNATIVES (before, alt); return; } case EXIT_BLOCK_EXPR: { tree block = TREE_OPERAND (exp, 0); struct alternatives *alt = alternatives; while (alt->block != block) alt = alt->outer; done_alternative (before, alt); SET_ALL (before); return; } case SWITCH_EXPR: { struct alternatives alt; word buf[2]; check_init (TREE_OPERAND (exp, 0), before); BEGIN_ALTERNATIVES (before, alt); alt.saved = ALLOC_BUFFER(buf, num_current_words); COPY (alt.saved, before); alt.block = exp; check_init (TREE_OPERAND (exp, 1), before); done_alternative (before, &alt); if (! SWITCH_HAS_DEFAULT (exp)) done_alternative (alt.saved, &alt); FREE_BUFFER(alt.saved, buf); END_ALTERNATIVES (before, alt); return; } case CASE_EXPR: case DEFAULT_EXPR: { int i; struct alternatives *alt = alternatives; while (TREE_CODE (alt->block) != SWITCH_EXPR) alt = alt->outer; COPYN (before, alt->saved, WORDS_NEEDED (2 * alt->num_locals)); for (i = alt->num_locals; i < num_current_locals; i++) CLEAR_ASSIGNED (before, i); break; } case TRY_EXPR: { tree try_clause = TREE_OPERAND (exp, 0); tree clause = TREE_OPERAND (exp, 1); word buf[2*2]; words tmp = (num_current_words <= 2 ? buf : ALLOC_WORDS (2 * num_current_words)); words save = tmp + num_current_words; struct alternatives alt; BEGIN_ALTERNATIVES (before, alt); COPY (save, before); COPY (tmp, save); check_init (try_clause, tmp); done_alternative (tmp, &alt); for ( ; clause != NULL_TREE; clause = TREE_CHAIN (clause)) { tree catch_clause = TREE_OPERAND (clause, 0); COPY (tmp, save); check_init (catch_clause, tmp); done_alternative (tmp, &alt); } if (tmp != buf) { FREE_WORDS (tmp); } END_ALTERNATIVES (before, alt); } return; case TRY_FINALLY_EXPR: { DECLARE_BUFFERS(tmp, 1); COPY (tmp, before); check_init (TREE_OPERAND (exp, 0), before); check_init (TREE_OPERAND (exp, 1), tmp); UNION (before, before, tmp); RELEASE_BUFFERS(tmp); } return; case RETURN_EXPR: case THROW_EXPR: if (TREE_OPERAND (exp, 0)) check_init (TREE_OPERAND (exp, 0), before); goto never_continues; case ERROR_MARK: never_continues: SET_ALL (before); return; case COND_EXPR: case TRUTH_ANDIF_EXPR: case TRUTH_ORIF_EXPR: { DECLARE_BUFFERS(when_true, 2); words when_false = when_true + num_current_words; check_bool_init (exp, before, when_false, when_true); INTERSECT (before, when_false, when_true); RELEASE_BUFFERS(when_true); } break; case NOP_EXPR: if (IS_EMPTY_STMT (exp)) break; /* ... else fall through ... */ case UNARY_PLUS_EXPR: case NEGATE_EXPR: case TRUTH_AND_EXPR: case TRUTH_OR_EXPR: case TRUTH_XOR_EXPR: case TRUTH_NOT_EXPR: case BIT_NOT_EXPR: case CONVERT_EXPR: case BIT_FIELD_REF: case FLOAT_EXPR: case FIX_TRUNC_EXPR: case INDIRECT_REF: case ADDR_EXPR: case NON_LVALUE_EXPR: case INSTANCEOF_EXPR: case FIX_CEIL_EXPR: case FIX_FLOOR_EXPR: case FIX_ROUND_EXPR: case ABS_EXPR: /* Avoid needless recursion. */ exp = TREE_OPERAND (exp, 0); goto again; case PREDECREMENT_EXPR: case PREINCREMENT_EXPR: case POSTDECREMENT_EXPR: case POSTINCREMENT_EXPR: tmp = get_variable_decl (TREE_OPERAND (exp, 0)); if (tmp != NULL_TREE && DECL_FINAL (tmp)) final_assign_error (DECL_NAME (tmp)); /* Avoid needless recursion. */ exp = TREE_OPERAND (exp, 0); goto again; case SAVE_EXPR: if (IS_INIT_CHECKED (exp)) return; IS_INIT_CHECKED (exp) = 1; exp = TREE_OPERAND (exp, 0); goto again; case COMPOUND_EXPR: case PLUS_EXPR: case MINUS_EXPR: case MULT_EXPR: case TRUNC_DIV_EXPR: case TRUNC_MOD_EXPR: case RDIV_EXPR: case LSHIFT_EXPR: case RSHIFT_EXPR: case URSHIFT_EXPR: case BIT_AND_EXPR: case BIT_XOR_EXPR: case BIT_IOR_EXPR: case EQ_EXPR: case NE_EXPR: case GT_EXPR: case GE_EXPR: case LT_EXPR: case LE_EXPR: case MAX_EXPR: case MIN_EXPR: case ARRAY_REF: case LROTATE_EXPR: case RROTATE_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR: case ROUND_DIV_EXPR: case CEIL_MOD_EXPR: case FLOOR_MOD_EXPR: case ROUND_MOD_EXPR: case EXACT_DIV_EXPR: case UNLT_EXPR: case UNLE_EXPR: case UNGT_EXPR: case UNGE_EXPR: case UNEQ_EXPR: case LTGT_EXPR: binop: check_init (TREE_OPERAND (exp, 0), before); /* Avoid needless recursion, especially for COMPOUND_EXPR. */ exp = TREE_OPERAND (exp, 1); goto again; case RESULT_DECL: case FUNCTION_DECL: case INTEGER_CST: case REAL_CST: case STRING_CST: case JAVA_EXC_OBJ_EXPR: break; case NEW_CLASS_EXPR: case CALL_EXPR: { tree func = TREE_OPERAND (exp, 0); tree x = TREE_OPERAND (exp, 1); if (TREE_CODE (func) == ADDR_EXPR) func = TREE_OPERAND (func, 0); check_init (func, before); for ( ; x != NULL_TREE; x = TREE_CHAIN (x)) check_init (TREE_VALUE (x), before); if (func == throw_node) goto never_continues; } break; case NEW_ARRAY_INIT: { tree x = CONSTRUCTOR_ELTS (TREE_OPERAND (exp, 0)); for ( ; x != NULL_TREE; x = TREE_CHAIN (x)) check_init (TREE_VALUE (x), before); } break; case EXPR_WITH_FILE_LOCATION: { location_t saved_location = input_location; tree saved_wfl = wfl; tree body = EXPR_WFL_NODE (exp); if (IS_EMPTY_STMT (body)) break; wfl = exp; #ifdef USE_MAPPED_LOCATION input_location = EXPR_LOCATION (exp); #else input_filename = EXPR_WFL_FILENAME (exp); input_line = EXPR_WFL_LINENO (exp); #endif check_init (body, before); input_location = saved_location; wfl = saved_wfl; } break; default: internal_error ("internal error in check-init: tree code not implemented: %s", tree_code_name [(int) TREE_CODE (exp)]); } }