1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
package org.eclipse.jdt.internal.compiler.ast;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import org.eclipse.jdt.internal.compiler.IAbstractSyntaxTreeVisitor;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.lookup.*;
public class Block extends Statement {
public Statement[] statements;
public int explicitDeclarations;
// the number of explicit declaration , used to create scope
public BlockScope scope;
public static final Block None = new Block(0);
public Block(int explicitDeclarations) {
this.explicitDeclarations = explicitDeclarations;
}
public FlowInfo analyseCode(
BlockScope currentScope,
FlowContext flowContext,
FlowInfo flowInfo) {
// empty block
if (statements == null)
return flowInfo;
for (int i = 0, max = statements.length; i < max; i++) {
Statement stat;
if (!flowInfo.complainIfUnreachable((stat = statements[i]), scope)) {
flowInfo = stat.analyseCode(scope, flowContext, flowInfo);
}
}
return flowInfo;
}
public static final Block EmptyWith(int sourceStart, int sourceEnd) {
//return an empty block which position is s and e
Block bk = new Block(0);
bk.sourceStart = sourceStart;
bk.sourceEnd = sourceEnd;
return bk;
}
/**
* Code generation for a block
*/
public void generateCode(BlockScope currentScope, CodeStream codeStream) {
if ((bits & IsReachableMASK) == 0) {
return;
}
int pc = codeStream.position;
if (statements != null) {
for (int i = 0, max = statements.length; i < max; i++) {
statements[i].generateCode(scope, codeStream);
}
} // for local variable debug attributes
if (scope != currentScope) { // was really associated with its own scope
codeStream.exitUserScope(scope);
}
codeStream.recordPositionsFrom(pc, this);
}
public boolean isEmptyBlock() {
return statements == null;
}
public void resolve(BlockScope upperScope) {
if (statements != null) {
scope =
explicitDeclarations == 0
? upperScope
: new BlockScope(upperScope, explicitDeclarations);
int i = 0, length = statements.length;
while (i < length)
statements[i++].resolve(scope);
}
}
public void resolveUsing(BlockScope givenScope) {
// this optimized resolve(...) is sent only on none empty blocks
scope = givenScope;
if (statements != null) {
int i = 0, length = statements.length;
while (i < length)
statements[i++].resolve(scope);
}
}
public String toString(int tab) {
/* slow code */
String s = tabString(tab);
if (this.statements == null) {
s += "{\n"; //$NON-NLS-1$
s += tabString(tab);
s += "}"; //$NON-NLS-1$
return s;
}
// s = s + (explicitDeclarations != 0
// ? " { // ---scope needed for "+String.valueOf(explicitDeclarations) +" locals------------ \n"
// : "{// ---NO scope needed------ \n") ;
s += "{\n"; //$NON-NLS-1$
s += this.toStringStatements(tab);
s += tabString(tab);
s += "}"; //$NON-NLS-1$
return s;
}
public String toStringStatements(int tab) {
if (this.statements == null)
return ""; //$NON-NLS-1$
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < statements.length; i++) {
buffer.append(statements[i].toString(tab + 1));
if (statements[i] instanceof Block) {
buffer.append("\n"); //$NON-NLS-1$
} else {
buffer.append(";\n"); //$NON-NLS-1$
}
};
return buffer.toString();
}
public void traverse(
IAbstractSyntaxTreeVisitor visitor,
BlockScope blockScope) {
if (visitor.visit(this, blockScope)) {
if (statements != null) {
int statementLength = statements.length;
for (int i = 0; i < statementLength; i++)
statements[i].traverse(visitor, scope);
}
}
visitor.endVisit(this, blockScope);
}
}
|
