KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > bcel > classfile > LineNumberTable


1 /*
2  * Copyright 2000-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 package org.apache.bcel.classfile;
18
19 import java.io.DataInputStream JavaDoc;
20 import java.io.DataOutputStream JavaDoc;
21 import java.io.IOException JavaDoc;
22 import org.apache.bcel.Constants;
23
24 /**
25  * This class represents a table of line numbers for debugging
26  * purposes. This attribute is used by the <em>Code</em> attribute. It
27  * contains pairs of PCs and line numbers.
28  *
29  * @version $Id: LineNumberTable.java 386056 2006-03-15 11:31:56Z tcurdt $
30  * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
31  * @see Code
32  * @see LineNumber
33  */
34 public final class LineNumberTable extends Attribute {
35
36     private int line_number_table_length;
37     private LineNumber[] line_number_table; // Table of line/numbers pairs
38
39
40     /*
41      * Initialize from another object. Note that both objects use the same
42      * references (shallow copy). Use copy() for a physical copy.
43      */
44     public LineNumberTable(LineNumberTable c) {
45         this(c.getNameIndex(), c.getLength(), c.getLineNumberTable(), c.getConstantPool());
46     }
47
48
49     /*
50      * @param name_index Index of name
51      * @param length Content length in bytes
52      * @param line_number_table Table of line/numbers pairs
53      * @param constant_pool Array of constants
54      */
55     public LineNumberTable(int name_index, int length, LineNumber[] line_number_table,
56             ConstantPool constant_pool) {
57         super(Constants.ATTR_LINE_NUMBER_TABLE, name_index, length, constant_pool);
58         setLineNumberTable(line_number_table);
59     }
60
61
62     /**
63      * Construct object from file stream.
64      * @param name_index Index of name
65      * @param length Content length in bytes
66      * @param file Input stream
67      * @param constant_pool Array of constants
68      * @throws IOException
69      */
70     LineNumberTable(int name_index, int length, DataInputStream JavaDoc file, ConstantPool constant_pool)
71             throws IOException JavaDoc {
72         this(name_index, length, (LineNumber[]) null, constant_pool);
73         line_number_table_length = (file.readUnsignedShort());
74         line_number_table = new LineNumber[line_number_table_length];
75         for (int i = 0; i < line_number_table_length; i++) {
76             line_number_table[i] = new LineNumber(file);
77         }
78     }
79
80
81     /**
82      * Called by objects that are traversing the nodes of the tree implicitely
83      * defined by the contents of a Java class. I.e., the hierarchy of methods,
84      * fields, attributes, etc. spawns a tree of objects.
85      *
86      * @param v Visitor object
87      */
88     public void accept( Visitor v ) {
89         v.visitLineNumberTable(this);
90     }
91
92
93     /**
94      * Dump line number table attribute to file stream in binary format.
95      *
96      * @param file Output file stream
97      * @throws IOException
98      */
99     public final void dump( DataOutputStream JavaDoc file ) throws IOException JavaDoc {
100         super.dump(file);
101         file.writeShort(line_number_table_length);
102         for (int i = 0; i < line_number_table_length; i++) {
103             line_number_table[i].dump(file);
104         }
105     }
106
107
108     /**
109      * @return Array of (pc offset, line number) pairs.
110      */
111     public final LineNumber[] getLineNumberTable() {
112         return line_number_table;
113     }
114
115
116     /**
117      * @param line_number_table the line number entries for this table
118      */
119     public final void setLineNumberTable( LineNumber[] line_number_table ) {
120         this.line_number_table = line_number_table;
121         line_number_table_length = (line_number_table == null) ? 0 : line_number_table.length;
122     }
123
124
125     /**
126      * @return String representation.
127      */
128     public final String JavaDoc toString() {
129         StringBuffer JavaDoc buf = new StringBuffer JavaDoc();
130         StringBuffer JavaDoc line = new StringBuffer JavaDoc();
131         String JavaDoc newLine = System.getProperty("line.separator", "\n");
132         for (int i = 0; i < line_number_table_length; i++) {
133             line.append(line_number_table[i].toString());
134             if (i < line_number_table_length - 1) {
135                 line.append(", ");
136             }
137             if (line.length() > 72) {
138                 line.append(newLine);
139                 buf.append(line.toString());
140                 line.setLength(0);
141             }
142         }
143         buf.append(line);
144         return buf.toString();
145     }
146
147
148     /**
149      * Map byte code positions to source code lines.
150      *
151      * @param pos byte code offset
152      * @return corresponding line in source code
153      */
154     public int getSourceLine( int pos ) {
155         int l = 0, r = line_number_table_length - 1;
156         if (r < 0) {
157             return -1;
158         }
159         int min_index = -1, min = -1;
160         /* Do a binary search since the array is ordered.
161          */
162         do {
163             int i = (l + r) / 2;
164             int j = line_number_table[i].getStartPC();
165             if (j == pos) {
166                 return line_number_table[i].getLineNumber();
167             } else if (pos < j) {
168                 r = i - 1;
169             } else {
170                 l = i + 1;
171             }
172             /* If exact match can't be found (which is the most common case)
173              * return the line number that corresponds to the greatest index less
174              * than pos.
175              */
176             if (j < pos && j > min) {
177                 min = j;
178                 min_index = i;
179             }
180         } while (l <= r);
181         /* It's possible that we did not find any valid entry for the bytecode
182          * offset we were looking for.
183          */
184         if (min_index < 0) {
185             return -1;
186         }
187         return line_number_table[min_index].getLineNumber();
188     }
189
190
191     /**
192      * @return deep copy of this attribute
193      */
194     public Attribute copy( ConstantPool _constant_pool ) {
195         LineNumberTable c = (LineNumberTable) clone();
196         c.line_number_table = new LineNumber[line_number_table_length];
197         for (int i = 0; i < line_number_table_length; i++) {
198             c.line_number_table[i] = line_number_table[i].copy();
199         }
200         c.constant_pool = _constant_pool;
201         return c;
202     }
203
204
205     public final int getTableLength() {
206         return line_number_table_length;
207     }
208 }
209
Popular Tags