Add field for external parser to pref page
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ISourceElementRequestor.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler;
12
13 import net.sourceforge.phpdt.core.compiler.IProblem;
14
15 /*
16  * Part of the source element parser responsible for building the output.
17  * It gets notified of structural information as they are detected, relying
18  * on the requestor to assemble them together, based on the notifications it got.
19  *
20  * The structural investigation includes:
21  * - package statement
22  * - import statements
23  * - top-level types: package member, member types (member types of member types...)
24  * - fields
25  * - methods
26  *
27  * If reference information is requested, then all source constructs are
28  * investigated and type, field & method references are provided as well.
29  *
30  * Any (parsing) problem encountered is also provided.
31  *
32  * All positions are relative to the exact source fed to the parser.
33  *
34  * Elements which are complex are notified in two steps:
35  * - enter<Element> : once the element header has been identified
36  * - exit<Element> : once the element has been fully consumed
37  *
38  * other simpler elements (package, import) are read all at once:
39  * - accept<Element>
40  */
41  
42 public interface ISourceElementRequestor {
43 void acceptConstructorReference(char[] typeName, int argCount, int sourcePosition);
44 void acceptFieldReference(char[] fieldName, int sourcePosition);
45 /**
46  * @param declarationStart This is the position of the first character of the
47  *                                                 import keyword.
48  * @param declarationEnd This is the position of the ';' ending the import statement
49  *                                               or the end of the comment following the import.
50  * @param name This is the name of the import like specified in the source including the dots. The '.*'
51  *             is never included in the name.
52  * @param onDemand set to true if the import is an import on demand (e.g. import java.io.*). False otherwise.
53  */
54 void acceptImport(
55         int declarationStart,
56         int declarationEnd,
57         char[] name,
58         boolean onDemand);
59 /*
60  * Table of line separator position. This table is passed once at the end
61  * of the parse action, so as to allow computation of normalized ranges.
62  *
63  * A line separator might corresponds to several characters in the source,
64  * 
65  */
66 void acceptLineSeparatorPositions(int[] positions);
67 void acceptMethodReference(char[] methodName, int argCount, int sourcePosition);
68 void acceptPackage(
69         int declarationStart,
70         int declarationEnd,
71         char[] name);
72 void acceptProblem(IProblem problem);
73 void acceptTypeReference(char[][] typeName, int sourceStart, int sourceEnd);
74 void acceptTypeReference(char[] typeName, int sourcePosition);
75 void acceptUnknownReference(char[][] name, int sourceStart, int sourceEnd);
76 void acceptUnknownReference(char[] name, int sourcePosition);
77 void enterClass(
78         int declarationStart,
79         int modifiers,
80         char[] name,
81         int nameSourceStart,
82         int nameSourceEnd,
83         char[] superclass,
84         char[][] superinterfaces);
85 void enterCompilationUnit();
86 void enterConstructor(
87         int declarationStart,
88         int modifiers,
89         char[] name,
90         int nameSourceStart,
91         int nameSourceEnd,      
92         char[][] parameterTypes,
93         char[][] parameterNames,
94         char[][] exceptionTypes);
95 void enterField(
96         int declarationStart,
97         int modifiers,
98         char[] type,
99         char[] name,
100         int nameSourceStart,
101         int nameSourceEnd);
102 void enterInitializer(
103         int declarationStart,
104         int modifiers);
105 void enterInterface(
106         int declarationStart,
107         int modifiers,
108         char[] name,
109         int nameSourceStart,
110         int nameSourceEnd,
111         char[][] superinterfaces);
112 void enterMethod(
113         int declarationStart,
114         int modifiers,
115         char[] returnType,
116         char[] name,
117         int nameSourceStart,
118         int nameSourceEnd,      
119         char[][] parameterTypes,
120         char[][] parameterNames,
121         char[][] exceptionTypes);
122 void exitClass(int declarationEnd);
123 void exitCompilationUnit(int declarationEnd);
124 void exitConstructor(int declarationEnd);
125 /*
126  * - No initialization source for now -
127  * initializationSource denotes the source of the expression used for initializing
128  * the field if any (if no source, then it is null).
129  *
130  * Note: the initializationSource will be used in case we do need to type check
131  *      against source models, and thus the only interesting use for it is field
132  *  constant propagation. Therefore, the initializationSource will only be non
133  *  null for final fields (so as to minimize char[] allocations).
134  */
135 void exitField(/*char[] initializationSource, */int declarationEnd);
136 void exitInitializer(int declarationEnd);
137 void exitInterface(int declarationEnd);
138 void exitMethod(int declarationEnd);
139 }