--- /dev/null
+/**********************************************************************
+Copyright (c) 2002 IBM Corp. and others.
+All rights reserved. This program and the accompanying materials
+are made available under the terms of the Common Public License v0.5
+which accompanies this distribution, and is available at
+http://www.eclipse.org/legal/cpl-v05.html
+
+Contributors:
+ IBM Corporation - initial API and implementation
+**********************************************************************/
+
+package net.sourceforge.phpdt.core.compiler;
+
+import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReasons;
+
+/**
+ * Description of a Java problem, as detected by the compiler or some of the underlying
+ * technology reusing the compiler.
+ * A problem provides access to:
+ * <ul>
+ * <li> its location (originating source file name, source position, line number), </li>
+ * <li> its message description and a predicate to check its severity (warning or error). </li>
+ * <li> its ID : an number identifying the very nature of this problem. All possible IDs are listed
+ * as constants on this interface. </li>
+ * </ul>
+ *
+ * Note: the compiler produces IProblems internally, which are turned into markers by the JavaBuilder
+ * so as to persist problem descriptions. This explains why there is no API allowing to reach IProblem detected
+ * when compiling. However, the Java problem markers carry equivalent information to IProblem, in particular
+ * their ID (attribute "id") is set to one of the IDs defined on this interface.
+ *
+ * @since 2.0
+ */
+public interface IProblem {
+
+ /**
+ * Answer back the original arguments recorded into the problem.
+ * @return the original arguments recorded into the problem
+ */
+ String[] getArguments();
+
+ /**
+ * Returns the problem id
+ *
+ * @return the problem id
+ */
+ int getID();
+
+ /**
+ * Answer a localized, human-readable message string which describes the problem.
+ *
+ * @return a localized, human-readable message string which describes the problem
+ */
+ String getMessage();
+
+ /**
+ * Answer the file name in which the problem was found.
+ *
+ * @return the file name in which the problem was found
+ */
+ char[] getOriginatingFileName();
+
+ /**
+ * Answer the end position of the problem (inclusive), or -1 if unknown.
+ *
+ * @return the end position of the problem (inclusive), or -1 if unknown
+ */
+ int getSourceEnd();
+
+ /**
+ * Answer the line number in source where the problem begins.
+ *
+ * @return the line number in source where the problem begins
+ */
+ int getSourceLineNumber();
+
+ /**
+ * Answer the start position of the problem (inclusive), or -1 if unknown.
+ *
+ * @return the start position of the problem (inclusive), or -1 if unknown
+ */
+ int getSourceStart();
+
+ /**
+ * Checks the severity to see if the Error bit is set.
+ *
+ * @return true if the Error bit is set for the severity, false otherwise
+ */
+ boolean isError();
+
+ /**
+ * Checks the severity to see if the Error bit is not set.
+ *
+ * @return true if the Error bit is not set for the severity, false otherwise
+ */
+ boolean isWarning();
+
+ /**
+ * Set the end position of the problem (inclusive), or -1 if unknown.
+ * Used for shifting problem positions.
+ *
+ * @param sourceEnd the given end position
+ */
+ void setSourceEnd(int sourceEnd);
+
+ /**
+ * Set the line number in source where the problem begins.
+ *
+ * @param lineNumber the given line number
+ */
+ void setSourceLineNumber(int lineNumber);
+
+ /**
+ * Set the start position of the problem (inclusive), or -1 if unknown.
+ * Used for shifting problem positions.
+ *
+ * @param the given start position
+ */
+ void setSourceStart(int sourceStart);
+
+ /**
+ * Problem Categories
+ * The high bits of a problem ID contains information about the category of a problem.
+ * e.g. (problemID & TypeRelated) != 0, indicates that this problem is type related.
+ *
+ * A problem category can help to implement custom problem filters. Indeed, when numerous problems
+ * are listed, focusing on import related problems first might be relevant.
+ *
+ * When a problem is tagged as Internal, it means that no change other than a local source code change
+ * can fix the corresponding problem.
+ */
+ int TypeRelated = 0x01000000;
+ int FieldRelated = 0x02000000;
+ int MethodRelated = 0x04000000;
+ int ConstructorRelated = 0x08000000;
+ int ImportRelated = 0x10000000;
+ int Internal = 0x20000000;
+ int Syntax = 0x40000000;
+
+ /**
+ * Mask to use in order to filter out the category portion of the problem ID.
+ */
+ int IgnoreCategoriesMask = 0xFFFFFF;
+
+ /**
+ * Below are listed all available problem IDs. Note that this list could be augmented in the future,
+ * as new features are added to the Java core implementation.
+ */
+
+ /**
+ * ID reserved for referencing an internal error inside the JavaCore implementation which
+ * may be surfaced as a problem associated with the compilation unit which caused it to occur.
+ */
+ int Unclassified = 0;
+
+ /**
+ * Generic type related problems
+ */
+ int ObjectHasNoSuperclass = TypeRelated + 1;
+ int UndefinedType = TypeRelated + 2;
+ int NotVisibleType = TypeRelated + 3;
+ int AmbiguousType = TypeRelated + 4;
+ int UsingDeprecatedType = TypeRelated + 5;
+ int InternalTypeNameProvided = TypeRelated + 6;
+
+ int IncompatibleTypesInEqualityOperator = TypeRelated + 15;
+ int IncompatibleTypesInConditionalOperator = TypeRelated + 16;
+ int TypeMismatch = TypeRelated + 17;
+
+ /**
+ * Inner types related problems
+ */
+ int MissingEnclosingInstanceForConstructorCall = TypeRelated + 20;
+ int MissingEnclosingInstance = TypeRelated + 21;
+ int IncorrectEnclosingInstanceReference = TypeRelated + 22;
+ int IllegalEnclosingInstanceSpecification = TypeRelated + 23;
+ int CannotDefineStaticInitializerInLocalType = Internal + 24;
+ int OuterLocalMustBeFinal = Internal + 25;
+ int CannotDefineInterfaceInLocalType = Internal + 26;
+ int IllegalPrimitiveOrArrayTypeForEnclosingInstance = TypeRelated + 27;
+ int AnonymousClassCannotExtendFinalClass = TypeRelated + 29;
+
+ // variables
+ int UndefinedName = 50;
+ int UninitializedLocalVariable = Internal + 51;
+ int VariableTypeCannotBeVoid = Internal + 52;
+ int VariableTypeCannotBeVoidArray = Internal + 53;
+ int CannotAllocateVoidArray = Internal + 54;
+ // local variables
+ int RedefinedLocal = Internal + 55;
+ int RedefinedArgument = Internal + 56;
+ int DuplicateFinalLocalInitialization = Internal + 57;
+ // final local variables
+ int FinalOuterLocalAssignment = Internal + 60;
+ int LocalVariableIsNeverUsed = Internal + 61;
+ int ArgumentIsNeverUsed = Internal + 62;
+ int BytecodeExceeds64KLimit = Internal + 63;
+ int BytecodeExceeds64KLimitForClinit = Internal + 64;
+ int TooManyArgumentSlots = Internal + 65;
+ int TooManyLocalVariableSlots = Internal + 66;
+
+ // fields
+ int UndefinedField = FieldRelated + 70;
+ int NotVisibleField = FieldRelated + 71;
+ int AmbiguousField = FieldRelated + 72;
+ int UsingDeprecatedField = FieldRelated + 73;
+ int NonStaticFieldFromStaticInvocation = FieldRelated + 74;
+ int ReferenceToForwardField = FieldRelated + Internal + 75;
+
+ // blank final fields
+ int FinalFieldAssignment = FieldRelated + 80;
+ int UninitializedBlankFinalField = FieldRelated + 81;
+ int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
+
+ // methods
+ int UndefinedMethod = MethodRelated + 100;
+ int NotVisibleMethod = MethodRelated + 101;
+ int AmbiguousMethod = MethodRelated + 102;
+ int UsingDeprecatedMethod = MethodRelated + 103;
+ int DirectInvocationOfAbstractMethod = MethodRelated + 104;
+ int VoidMethodReturnsValue = MethodRelated + 105;
+ int MethodReturnsVoid = MethodRelated + 106;
+ int MethodRequiresBody = Internal + MethodRelated + 107;
+ int ShouldReturnValue = Internal + MethodRelated + 108;
+ int MethodButWithConstructorName = MethodRelated + 110;
+ int MissingReturnType = TypeRelated + 111;
+ int BodyForNativeMethod = Internal + MethodRelated + 112;
+ int BodyForAbstractMethod = Internal + MethodRelated + 113;
+ int NoMessageSendOnBaseType = MethodRelated + 114;
+ int ParameterMismatch = MethodRelated + 115;
+ int NoMessageSendOnArrayType = MethodRelated + 116;
+
+ // constructors
+ int UndefinedConstructor = ConstructorRelated + 130;
+ int NotVisibleConstructor = ConstructorRelated + 131;
+ int AmbiguousConstructor = ConstructorRelated + 132;
+ int UsingDeprecatedConstructor = ConstructorRelated + 133;
+ // explicit constructor calls
+ int InstanceFieldDuringConstructorInvocation = ConstructorRelated + 135;
+ int InstanceMethodDuringConstructorInvocation = ConstructorRelated + 136;
+ int RecursiveConstructorInvocation = ConstructorRelated + 137;
+ int ThisSuperDuringConstructorInvocation = ConstructorRelated + 138;
+ // implicit constructor calls
+ int UndefinedConstructorInDefaultConstructor = ConstructorRelated + 140;
+ int NotVisibleConstructorInDefaultConstructor = ConstructorRelated + 141;
+ int AmbiguousConstructorInDefaultConstructor = ConstructorRelated + 142;
+ int UndefinedConstructorInImplicitConstructorCall = ConstructorRelated + 143;
+ int NotVisibleConstructorInImplicitConstructorCall = ConstructorRelated + 144;
+ int AmbiguousConstructorInImplicitConstructorCall = ConstructorRelated + 145;
+ int UnhandledExceptionInDefaultConstructor = TypeRelated + 146;
+ int UnhandledExceptionInImplicitConstructorCall = TypeRelated + 147;
+
+ // expressions
+ int ArrayReferenceRequired = Internal + 150;
+ int NoImplicitStringConversionForCharArrayExpression = Internal + 151;
+ // constant expressions
+ int StringConstantIsExceedingUtf8Limit = Internal + 152;
+ int NonConstantExpression = 153;
+ int NumericValueOutOfRange = Internal + 154;
+ // cast expressions
+ int IllegalCast = TypeRelated + 156;
+ // allocations
+ int InvalidClassInstantiation = TypeRelated + 157;
+ int CannotDefineDimensionExpressionsWithInit = Internal + 158;
+ int MustDefineEitherDimensionExpressionsOrInitializer = Internal + 159;
+ // operators
+ int InvalidOperator = Internal + 160;
+ // statements
+ int CodeCannotBeReached = Internal + 161;
+ int CannotReturnInInitializer = Internal + 162;
+ int InitializerMustCompleteNormally = Internal + 163;
+
+ // assert
+ int InvalidVoidExpression = Internal + 164;
+ // try
+ int MaskedCatch = TypeRelated + 165;
+ int DuplicateDefaultCase = 166;
+ int UnreachableCatch = TypeRelated + MethodRelated + 167;
+ int UnhandledException = TypeRelated + 168;
+ // switch
+ int IncorrectSwitchType = TypeRelated + 169;
+ int DuplicateCase = FieldRelated + 170;
+ // labelled
+ int DuplicateLabel = Internal + 171;
+ int InvalidBreak = Internal + 172;
+ int InvalidContinue = Internal + 173;
+ int UndefinedLabel = Internal + 174;
+ //synchronized
+ int InvalidTypeToSynchronized = Internal + 175;
+ int InvalidNullToSynchronized = Internal + 176;
+ // throw
+ int CannotThrowNull = Internal + 177;
+
+ // inner emulation
+ int NeedToEmulateFieldReadAccess = FieldRelated + 190;
+ int NeedToEmulateFieldWriteAccess = FieldRelated + 191;
+ int NeedToEmulateMethodAccess = MethodRelated + 192;
+ int NeedToEmulateConstructorAccess = MethodRelated + 193;
+
+ //inherited name hides enclosing name (sort of ambiguous)
+ int InheritedMethodHidesEnclosingName = MethodRelated + 195;
+ int InheritedFieldHidesEnclosingName = FieldRelated + 196;
+ int InheritedTypeHidesEnclosingName = TypeRelated + 197;
+
+ // miscellaneous
+ int ThisInStaticContext = Internal + 200;
+ int StaticMethodRequested = Internal + MethodRelated + 201;
+ int IllegalDimension = Internal + 202;
+ int InvalidTypeExpression = Internal + 203;
+ int ParsingError = Syntax + Internal + 204;
+ int ParsingErrorNoSuggestion = Syntax + Internal + 205;
+ int InvalidUnaryExpression = Syntax + Internal + 206;
+
+ // syntax errors
+ int InterfaceCannotHaveConstructors = Syntax + Internal + 207;
+ int ArrayConstantsOnlyInArrayInitializers = Syntax + Internal + 208;
+ int ParsingErrorOnKeyword = Syntax + Internal + 209;
+ int ParsingErrorOnKeywordNoSuggestion = Syntax + Internal + 210;
+
+ int UnmatchedBracket = Syntax + Internal + 220;
+ int NoFieldOnBaseType = FieldRelated + 221;
+ int InvalidExpressionAsStatement = Syntax + Internal + 222;
+
+ // scanner errors
+ int EndOfSource = Syntax + Internal + 250;
+ int InvalidHexa = Syntax + Internal + 251;
+ int InvalidOctal = Syntax + Internal + 252;
+ int InvalidCharacterConstant = Syntax + Internal + 253;
+ int InvalidEscape = Syntax + Internal + 254;
+ int InvalidInput = Syntax + Internal + 255;
+ int InvalidUnicodeEscape = Syntax + Internal + 256;
+ int InvalidFloat = Syntax + Internal + 257;
+ int NullSourceString = Syntax + Internal + 258;
+ int UnterminatedString = Syntax + Internal + 259;
+ int UnterminatedComment = Syntax + Internal + 260;
+
+ // type related problems
+ int InterfaceCannotHaveInitializers = TypeRelated + 300;
+ int DuplicateModifierForType = TypeRelated + 301;
+ int IllegalModifierForClass = TypeRelated + 302;
+ int IllegalModifierForInterface = TypeRelated + 303;
+ int IllegalModifierForMemberClass = TypeRelated + 304;
+ int IllegalModifierForMemberInterface = TypeRelated + 305;
+ int IllegalModifierForLocalClass = TypeRelated + 306;
+
+ int IllegalModifierCombinationFinalAbstractForClass = TypeRelated + 308;
+ int IllegalVisibilityModifierForInterfaceMemberType = TypeRelated + 309;
+ int IllegalVisibilityModifierCombinationForMemberType = TypeRelated + 310;
+ int IllegalStaticModifierForMemberType = TypeRelated + 311;
+ int SuperclassMustBeAClass = TypeRelated + 312;
+ int ClassExtendFinalClass = TypeRelated + 313;
+ int DuplicateSuperInterface = TypeRelated + 314;
+ int SuperInterfaceMustBeAnInterface = TypeRelated + 315;
+ int HierarchyCircularitySelfReference = TypeRelated + 316;
+ int HierarchyCircularity = TypeRelated + 317;
+ int HidingEnclosingType = TypeRelated + 318;
+ int DuplicateNestedType = TypeRelated + 319;
+ int CannotThrowType = TypeRelated + 320;
+ int PackageCollidesWithType = TypeRelated + 321;
+ int TypeCollidesWithPackage = TypeRelated + 322;
+ int DuplicateTypes = TypeRelated + 323;
+ int IsClassPathCorrect = TypeRelated + 324;
+ int PublicClassMustMatchFileName = TypeRelated + 325;
+ int MustSpecifyPackage = 326;
+ int HierarchyHasProblems = TypeRelated + 327;
+ int PackageIsNotExpectedPackage = 328;
+
+ // int InvalidSuperclassBase = TypeRelated + 329; // reserved to 334 included
+ int SuperclassNotFound = TypeRelated + 329 + ProblemReasons.NotFound; // TypeRelated + 330
+ int SuperclassNotVisible = TypeRelated + 329 + ProblemReasons.NotVisible; // TypeRelated + 331
+ int SuperclassAmbiguous = TypeRelated + 329 + ProblemReasons.Ambiguous; // TypeRelated + 332
+ int SuperclassInternalNameProvided = TypeRelated + 329 + ProblemReasons.InternalNameProvided; // TypeRelated + 333
+ int SuperclassInheritedNameHidesEnclosingName = TypeRelated + 329 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 334
+
+ // int InvalidInterfaceBase = TypeRelated + 334; // reserved to 339 included
+ int InterfaceNotFound = TypeRelated + 334 + ProblemReasons.NotFound; // TypeRelated + 335
+ int InterfaceNotVisible = TypeRelated + 334 + ProblemReasons.NotVisible; // TypeRelated + 336
+ int InterfaceAmbiguous = TypeRelated + 334 + ProblemReasons.Ambiguous; // TypeRelated + 337
+ int InterfaceInternalNameProvided = TypeRelated + 334 + ProblemReasons.InternalNameProvided; // TypeRelated + 338
+ int InterfaceInheritedNameHidesEnclosingName = TypeRelated + 334 + ProblemReasons.InheritedNameHidesEnclosingName; // TypeRelated + 339
+
+ // field related problems
+ int DuplicateField = FieldRelated + 340;
+ int DuplicateModifierForField = FieldRelated + 341;
+ int IllegalModifierForField = FieldRelated + 342;
+ int IllegalModifierForInterfaceField = FieldRelated + 343;
+ int IllegalVisibilityModifierCombinationForField = FieldRelated + 344;
+ int IllegalModifierCombinationFinalVolatileForField = FieldRelated + 345;
+ int UnexpectedStaticModifierForField = FieldRelated + 346;
+
+ // int FieldTypeProblemBase = FieldRelated + 349; //reserved to 354
+ int FieldTypeNotFound = FieldRelated + 349 + ProblemReasons.NotFound; // FieldRelated + 350
+ int FieldTypeNotVisible = FieldRelated + 349 + ProblemReasons.NotVisible; // FieldRelated + 351
+ int FieldTypeAmbiguous = FieldRelated + 349 + ProblemReasons.Ambiguous; // FieldRelated + 352
+ int FieldTypeInternalNameProvided = FieldRelated + 349 + ProblemReasons.InternalNameProvided; // FieldRelated + 353
+ int FieldTypeInheritedNameHidesEnclosingName = FieldRelated + 349 + ProblemReasons.InheritedNameHidesEnclosingName; // FieldRelated + 354
+
+ // method related problems
+ int DuplicateMethod = MethodRelated + 355;
+ int IllegalModifierForArgument = MethodRelated + 356;
+ int DuplicateModifierForMethod = MethodRelated + 357;
+ int IllegalModifierForMethod = MethodRelated + 358;
+ int IllegalModifierForInterfaceMethod = MethodRelated + 359;
+ int IllegalVisibilityModifierCombinationForMethod = MethodRelated + 360;
+ int UnexpectedStaticModifierForMethod = MethodRelated + 361;
+ int IllegalAbstractModifierCombinationForMethod = MethodRelated + 362;
+ int AbstractMethodInAbstractClass = MethodRelated + 363;
+ int ArgumentTypeCannotBeVoid = MethodRelated + 364;
+ int ArgumentTypeCannotBeVoidArray = MethodRelated + 365;
+ int ReturnTypeCannotBeVoidArray = MethodRelated + 366;
+ int NativeMethodsCannotBeStrictfp = MethodRelated + 367;
+ int DuplicateModifierForArgument = MethodRelated + 368;
+
+ // int ArgumentProblemBase = MethodRelated + 369; // reserved to 374 included.
+ int ArgumentTypeNotFound = MethodRelated + 369 + ProblemReasons.NotFound; // MethodRelated + 370
+ int ArgumentTypeNotVisible = MethodRelated + 369 + ProblemReasons.NotVisible; // MethodRelated + 371
+ int ArgumentTypeAmbiguous = MethodRelated + 369 + ProblemReasons.Ambiguous; // MethodRelated + 372
+ int ArgumentTypeInternalNameProvided = MethodRelated + 369 + ProblemReasons.InternalNameProvided; // MethodRelated + 373
+ int ArgumentTypeInheritedNameHidesEnclosingName = MethodRelated + 369 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 374
+
+ // int ExceptionTypeProblemBase = MethodRelated + 374; // reserved to 379 included.
+ int ExceptionTypeNotFound = MethodRelated + 374 + ProblemReasons.NotFound; // MethodRelated + 375
+ int ExceptionTypeNotVisible = MethodRelated + 374 + ProblemReasons.NotVisible; // MethodRelated + 376
+ int ExceptionTypeAmbiguous = MethodRelated + 374 + ProblemReasons.Ambiguous; // MethodRelated + 377
+ int ExceptionTypeInternalNameProvided = MethodRelated + 374 + ProblemReasons.InternalNameProvided; // MethodRelated + 378
+ int ExceptionTypeInheritedNameHidesEnclosingName = MethodRelated + 374 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 379
+
+ // int ReturnTypeProblemBase = MethodRelated + 379;
+ int ReturnTypeNotFound = MethodRelated + 379 + ProblemReasons.NotFound; // MethodRelated + 380
+ int ReturnTypeNotVisible = MethodRelated + 379 + ProblemReasons.NotVisible; // MethodRelated + 381
+ int ReturnTypeAmbiguous = MethodRelated + 379 + ProblemReasons.Ambiguous; // MethodRelated + 382
+ int ReturnTypeInternalNameProvided = MethodRelated + 379 + ProblemReasons.InternalNameProvided; // MethodRelated + 383
+ int ReturnTypeInheritedNameHidesEnclosingName = MethodRelated + 379 + ProblemReasons.InheritedNameHidesEnclosingName; // MethodRelated + 384
+
+ // import related problems
+ int ConflictingImport = ImportRelated + 385;
+ int DuplicateImport = ImportRelated + 386;
+ int CannotImportPackage = ImportRelated + 387;
+ int UnusedImport = ImportRelated + 388;
+
+ // int ImportProblemBase = ImportRelated + 389;
+ int ImportNotFound = ImportRelated + 389 + ProblemReasons.NotFound; // ImportRelated + 390
+ int ImportNotVisible = ImportRelated + 389 + ProblemReasons.NotVisible; // ImportRelated + 391
+ int ImportAmbiguous = ImportRelated + 389 + ProblemReasons.Ambiguous; // ImportRelated + 392
+ int ImportInternalNameProvided = ImportRelated + 389 + ProblemReasons.InternalNameProvided; // ImportRelated + 393
+ int ImportInheritedNameHidesEnclosingName = ImportRelated + 389 + ProblemReasons.InheritedNameHidesEnclosingName; // ImportRelated + 394
+
+
+ // local variable related problems
+ int DuplicateModifierForVariable = MethodRelated + 395;
+ int IllegalModifierForVariable = MethodRelated + 396;
+
+ // method verifier problems
+ int AbstractMethodMustBeImplemented = MethodRelated + 400;
+ int FinalMethodCannotBeOverridden = MethodRelated + 401;
+ int IncompatibleExceptionInThrowsClause = MethodRelated + 402;
+ int IncompatibleExceptionInInheritedMethodThrowsClause = MethodRelated + 403;
+ int IncompatibleReturnType = MethodRelated + 404;
+ int InheritedMethodReducesVisibility = MethodRelated + 405;
+ int CannotOverrideAStaticMethodWithAnInstanceMethod = MethodRelated + 406;
+ int CannotHideAnInstanceMethodWithAStaticMethod = MethodRelated + 407;
+ int StaticInheritedMethodConflicts = MethodRelated + 408;
+ int MethodReducesVisibility = MethodRelated + 409;
+ int OverridingNonVisibleMethod = MethodRelated + 410;
+ int AbstractMethodCannotBeOverridden = MethodRelated + 411;
+ int OverridingDeprecatedMethod = MethodRelated + 412;
+
+ // code snippet support
+ int CodeSnippetMissingClass = Internal + 420;
+ int CodeSnippetMissingMethod = Internal + 421;
+ int NonExternalizedStringLiteral = Internal + 261;
+ int CannotUseSuperInCodeSnippet = Internal + 422;
+
+ //constant pool
+ int TooManyConstantsInConstantPool = Internal + 430;
+
+ // 1.4 features
+ // assertion warning
+ int UseAssertAsAnIdentifier = Internal + 440;
+}
--- /dev/null
+/**********************************************************************
+Copyright (c) 2002 IBM Corp. and others.
+All rights reserved. This program and the accompanying materials
+are made available under the terms of the Common Public License v0.5
+which accompanies this distribution, and is available at
+http://www.eclipse.org/legal/cpl-v05.html
+
+Contributors:
+ IBM Corporation - initial API and implementation
+**********************************************************************/
+
+package net.sourceforge.phpdt.core.compiler;
+
+ /**
+ * Definition of a Java scanner, as returned by the <code>ToolFactory</code>.
+ * The scanner is responsible for tokenizing a given source, providing information about
+ * the nature of the token read, its positions and source equivalent.
+ *
+ * When the scanner has finished tokenizing, it answers an EOF token (<code>
+ * ITerminalSymbols#TokenNameEOF</code>.
+ *
+ * When encountering lexical errors, an <code>InvalidInputException</code> is thrown.
+ *
+ * @see org.eclipse.jdt.core.ToolFactory
+ * @see ITerminalSymbols
+ * @since 2.0
+ */
+public interface IScanner {
+
+ /**
+ * Answers the current identifier source, after unicode escape sequences have
+ * been translated into unicode characters.
+ * e.g. if original source was <code>\\u0061bc</code> then it will answer <code>abc</code>.
+ *
+ * @return the current identifier source, after unicode escape sequences have
+ * been translated into unicode characters
+ */
+ char[] getCurrentTokenSource();
+
+ /**
+ * Answers the starting position of the current token inside the original source.
+ * This position is zero-based and inclusive. It corresponds to the position of the first character
+ * which is part of this token. If this character was a unicode escape sequence, it points at the first
+ * character of this sequence.
+ *
+ * @return the starting position of the current token inside the original source
+ */
+ int getCurrentTokenStartPosition();
+
+ /**
+ * Answers the ending position of the current token inside the original source.
+ * This position is zero-based and inclusive. It corresponds to the position of the last character
+ * which is part of this token. If this character was a unicode escape sequence, it points at the last
+ * character of this sequence.
+ *
+ * @return the ending position of the current token inside the original source
+ */
+ int getCurrentTokenEndPosition();
+
+ /**
+ * Answers the starting position of a given line number. This line has to have been encountered
+ * already in the tokenization process (i.e. it cannot be used to compute positions of lines beyond
+ * current token). Once the entire source has been processed, it can be used without any limit.
+ * Line starting positions are zero-based, and start immediately after the previous line separator (if any).
+ *
+ * @param lineNumber the given line number
+ * @return the starting position of a given line number
+ */
+ int getLineStart(int lineNumber);
+
+ /**
+ * Answers the ending position of a given line number. This line has to have been encountered
+ * already in the tokenization process (i.e. it cannot be used to compute positions of lines beyond
+ * current token). Once the entire source has been processed, it can be used without any limit.
+ * Line ending positions are zero-based, and correspond to the last character of the line separator
+ * (in case multi-character line separators).
+ *
+ * @param lineNumber the given line number
+ * @return the ending position of a given line number
+ **/
+ int getLineEnd(int lineNumber);
+
+ /**
+ * Answers an array of the ending positions of the lines encountered so far. Line ending positions
+ * are zero-based, and correspond to the last character of the line separator (in case multi-character
+ * line separators).
+ *
+ * @return an array of the ending positions of the lines encountered so far
+ */
+ int[] getLineEnds();
+
+ /**
+ * Answers a 1-based line number using the lines which have been encountered so far. If the position
+ * is located beyond the current scanned line, then the last line number will be answered.
+ *
+ * @param charPosition the given character position
+ * @return a 1-based line number using the lines which have been encountered so far
+ */
+ int getLineNumber(int charPosition);
+
+ /**
+ * Read the next token in the source, and answers its ID as specified by <code>ITerminalSymbols</code>.
+ * Note that the actual token ID values are subject to change if new keywords were added to the language
+ * (i.e. 'assert' keyword in 1.4).
+ *
+ * @throws InvalidInputException - in case a lexical error was detected while reading the current token
+ */
+ int getNextToken() throws InvalidInputException;
+
+ /**
+ * Answers the original source being processed (not a copy of it).
+ *
+ * @return the original source being processed
+ */
+ char[] getSource();
+
+ /**
+ * Reposition the scanner on some portion of the original source. Once reaching the given <code>endPosition</code>
+ * it will answer EOF tokens (<code>ITerminalSymbols.TokenNameEOF</code>).
+ *
+ * @param startPosition the given start position
+ * @param endPosition the given end position
+ */
+ void resetTo(int startPosition, int endPosition);
+
+ /**
+ * Set the scanner source to process. By default, the scanner will consider starting at the beginning of the
+ * source until it reaches its end.
+ *
+ * @param source the given source
+ */
+ void setSource(char[] source);
+}
--- /dev/null
+/**********************************************************************
+Copyright (c) 2002 IBM Corp. and others.
+All rights reserved. This program and the accompanying materials
+are made available under the terms of the Common Public License v0.5
+which accompanies this distribution, and is available at
+http://www.eclipse.org/legal/cpl-v05.html
+
+Contributors:
+ IBM Corporation - initial API and implementation
+**********************************************************************/
+
+package net.sourceforge.phpdt.core.compiler;
+
+/**
+ * Maps each terminal symbol in the java-grammar into a unique integer.
+ * This integer is used to represent the terminal when computing a parsing action.
+ *
+ * Disclaimer : These constant values are generated automatically using a Java
+ * grammar, therefore their actual values are subject to change if new keywords
+ * were added to the language (i.e. 'assert' keyword in 1.4).
+ *
+ * @see IScanner
+ * @since 2.0
+ */
+public interface ITerminalSymbols {
+
+ // special tokens not part of grammar - not autogenerated
+ public final static int TokenNameWHITESPACE = 900,
+ TokenNameCOMMENT_LINE = 901,
+ TokenNameCOMMENT_BLOCK = 902,
+ TokenNameCOMMENT_JAVADOC = 903;
+
+ public final static int TokenNameIdentifier = 5,
+// TokenNameabstract = 98,
+// TokenNameassert = 118,
+// TokenNameboolean = 18,
+// // TokenNamebreak = 119,
+// TokenNamebyte = 19,
+// // TokenNamecase = 211,
+// TokenNamecatch = 225,
+// TokenNamechar = 20,
+// // TokenNameclass = 165,
+// // TokenNamecontinue = 120,
+// // TokenNamedefault = 212,
+// // TokenNamedo = 121,
+// TokenNamedouble = 21,
+// // TokenNameelse = 213,
+// // TokenNameextends = 243,
+// // TokenNamefalse = 37,
+// TokenNamefinal = 99,
+// TokenNamefinally = 226,
+// TokenNamefloat = 22,
+// // TokenNamefor = 122,
+// // TokenNameif = 123,
+// TokenNameimplements = 267,
+// TokenNameimport = 191,
+// TokenNameinstanceof = 65,
+// TokenNameint = 23,
+// TokenNameinterface = 180,
+// TokenNamelong = 24,
+// TokenNamenative = 100,
+// // TokenNamenew = 32,
+// // TokenNamenull = 38,
+// TokenNamepackage = 214,
+// TokenNameprivate = 101,
+// TokenNameprotected = 102,
+// TokenNamepublic = 103,
+// // TokenNamereturn = 124,
+// TokenNameshort = 25,
+// // TokenNamestatic = 94,
+// TokenNamestrictfp = 104,
+// TokenNamesuper = 34,
+// // TokenNameswitch = 125,
+// TokenNamesynchronized = 85,
+// TokenNamethis = 35,
+// TokenNamethrow = 126,
+// TokenNamethrows = 227,
+// TokenNametransient = 105,
+// // TokenNametrue = 39,
+// TokenNametry = 127,
+// TokenNamevoid = 26,
+// TokenNamevolatile = 106,
+// // TokenNamewhile = 117,
+ TokenNameIntegerLiteral = 40,
+ TokenNameLongLiteral = 41,
+ TokenNameFloatingPointLiteral = 42,
+ TokenNameDoubleLiteral = 43,
+ TokenNameCharacterLiteral = 44,
+ TokenNameStringLiteral = 45,
+ TokenNamePLUS_PLUS = 1,
+ TokenNameMINUS_MINUS = 2,
+ TokenNameEQUAL_EQUAL = 33,
+ TokenNameLESS_EQUAL = 66,
+ TokenNameGREATER_EQUAL = 67,
+ TokenNameNOT_EQUAL = 36,
+ TokenNameLEFT_SHIFT = 14,
+ TokenNameRIGHT_SHIFT = 11,
+ TokenNameUNSIGNED_RIGHT_SHIFT = 12,
+ TokenNamePLUS_EQUAL = 168,
+ TokenNameMINUS_EQUAL = 169,
+ TokenNameMULTIPLY_EQUAL = 170,
+ TokenNameDIVIDE_EQUAL = 171,
+ TokenNameAND_EQUAL = 172,
+ TokenNameOR_EQUAL = 173,
+ TokenNameXOR_EQUAL = 174,
+ TokenNameREMAINDER_EQUAL = 175,
+ TokenNameLEFT_SHIFT_EQUAL = 176,
+ TokenNameRIGHT_SHIFT_EQUAL = 177,
+ TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL = 178,
+ TokenNameOR_OR = 80,
+ TokenNameAND_AND = 79,
+ TokenNamePLUS = 3,
+ TokenNameMINUS = 4,
+ TokenNameNOT = 71,
+ TokenNameREMAINDER = 9,
+ TokenNameXOR = 63,
+ TokenNameAND = 62,
+ TokenNameMULTIPLY = 8,
+ TokenNameOR = 70,
+ TokenNameTWIDDLE = 72,
+ TokenNameDIVIDE = 10,
+ TokenNameGREATER = 68,
+ TokenNameLESS = 69,
+ TokenNameLPAREN = 7,
+ TokenNameRPAREN = 86,
+ TokenNameLBRACE = 110,
+ TokenNameRBRACE = 95,
+ TokenNameLBRACKET = 15,
+ TokenNameRBRACKET = 166,
+ TokenNameSEMICOLON = 64,
+ TokenNameQUESTION = 81,
+ TokenNameCOLON = 154,
+ TokenNameCOMMA = 90,
+ TokenNameDOT = 6,
+ TokenNameEQUAL = 167,
+ TokenNameEOF = 158,
+ TokenNameERROR = 307;
+
+// public final static int TokenNameKEYWORD = 1000;
+ public final static int TokenNameif = 1001;
+ public final static int TokenNameelseif = 1002;
+ public final static int TokenNameelse = 1003;
+ public final static int TokenNameendif = 1004;
+ public final static int TokenNamefor = 1005;
+ public final static int TokenNameendfor = 1006;
+ public final static int TokenNamewhile = 1007;
+ public final static int TokenNameendwhile = 1008;
+ public final static int TokenNameswitch = 1009;
+ public final static int TokenNamecase = 10010;
+ public final static int TokenNameendswitch = 1011;
+ public final static int TokenNamebreak = 1012;
+ public final static int TokenNamecontinue = 1013;
+ public final static int TokenNamereturn = 1014;
+ public final static int TokenNamedefine = 1015;
+ public final static int TokenNameinclude = 1016;
+ public final static int TokenNameinclude_once = 1017;
+ public final static int TokenNamerequire = 1018;
+ public final static int TokenNamerequire_once = 1019;
+ public final static int TokenNamefunction = 1020;
+ public final static int TokenNameclass = 1021;
+ public final static int TokenNamenew = 1022;
+ public final static int TokenNamedo = 1023;
+ public final static int TokenNameold_function = 1024;
+ public final static int TokenNamedefault = 1025;
+ public final static int TokenNameglobal = 1026;
+ public final static int TokenNamestatic = 1027;
+ public final static int TokenNameforeach = 1028;
+ public final static int TokenNameendforeach = 1029;
+ public final static int TokenNameextends = 1030;
+ // public final static int TokenNameempty = 1031;
+ // public final static int TokenNamearray = 1032;
+ public final static int TokenNameecho = 1033;
+ public final static int TokenNamevar = 1034;
+ public final static int TokenNameas = 1035;
+ public final static int TokenNameprint = 1036;
+ // public final static int TokenNameunset = 1037;
+ // public final static int TokenNameexit = 1038;
+ // public final static int TokenNamedie = 1039;
+ public final static int TokenNameand = 1040;
+ public final static int TokenNameor = 1041;
+ public final static int TokenNamexor = 1042;
+ public final static int TokenNamelist = 1043;
+ public final static int TokenNamenull = 1044;
+ public final static int TokenNamefalse = 1045;
+ public final static int TokenNametrue = 1046;
+}
git://secure.phpeclipse.com / phpeclipse.git / commitdiff