1 // $Id: control.h,v 1.57 2004/04/04 19:45:48 ericb Exp $ -*- c++ -*- 2 // 3 // This software is subject to the terms of the IBM Jikes Compiler 4 // License Agreement available at the following URL: 5 // http://ibm.com/developerworks/opensource/jikes. 6 // Copyright (C) 1996, 2004 IBM Corporation and others. All Rights Reserved. 7 // You must accept the terms of that agreement to use this software. 8 // 9 10 #ifndef control_INCLUDED 11 #define control_INCLUDED 12 13 #include "platform.h" 14 #include "symbol.h" 15 #include "tuple.h" 16 #include "set.h" 17 18 #ifdef HAVE_JIKES_NAMESPACE 19 namespace Jikes { // Open namespace Jikes block 20 #endif 21 22 class StoragePool; 23 class Option; 24 class Scanner; 25 class Parser; 26 class Semantic; 27 class LexStream; 28 class AstPackageDeclaration; 29 class AstName; 30 class TypeDependenceChecker; 31 32 // 33 // This class represents the control information common across all compilation 34 // units. It provides a cache for essential classes and objects, as well as 35 // the command line options in force. 36 // 37 class Control : public StringConstant 38 { 39 public: 40 int return_code; 41 Option& option; 42 SymbolTable classpath_table; 43 SymbolTable external_table; 44 45 unsigned dot_classpath_index; 46 Tuple<PathSymbol*> classpath; 47 Tuple<wchar_t*> bad_dirnames; 48 Tuple<wchar_t*> bad_zip_filenames; 49 Tuple<wchar_t*> bad_input_filenames; 50 Tuple<wchar_t*> unreadable_input_filenames; 51 Tuple<const wchar_t*> general_io_errors; 52 Tuple<const wchar_t*> general_io_warnings; 53 54 SystemTable* system_table; 55 Tuple<DirectorySymbol*> system_directories; 56 57 Semantic* system_semantic; 58 Tuple<Semantic*> semantic; 59 Tuple<TypeSymbol*> needs_body_work; 60 Tuple<TypeSymbol*> type_trash_bin; 61 62 NameSymbolMap unnamed_package_types; 63 64 SymbolSet input_java_file_set; 65 SymbolSet input_class_file_set; 66 SymbolSet expired_file_set; 67 SymbolSet recompilation_file_set; 68 69 Parser* parser; 70 Scanner* scanner; 71 72 // 73 // Tables for hashing everything we've seen so far. 74 // 75 LiteralLookupTable string_table; 76 LiteralLookupTable int_table; 77 LiteralLookupTable long_table; 78 LiteralLookupTable char_table; 79 LiteralLookupTable float_table; 80 LiteralLookupTable double_table; 81 NameLookupTable name_table; 82 TypeLookupTable type_table; 83 84 // 85 // This cache of name symbols is initialized in system.cpp. 86 // 87 NameSymbol* access_name_symbol; 88 NameSymbol* array_name_symbol; 89 NameSymbol* assert_name_symbol; 90 NameSymbol* block_init_name_symbol; 91 NameSymbol* class_name_symbol; 92 NameSymbol* clinit_name_symbol; 93 NameSymbol* clone_name_symbol; 94 NameSymbol* dot_name_symbol; 95 NameSymbol* dot_dot_name_symbol; 96 NameSymbol* Enum_name_symbol; 97 NameSymbol* equals_name_symbol; 98 NameSymbol* false_name_symbol; 99 NameSymbol* hashCode_name_symbol; 100 NameSymbol* init_name_symbol; 101 NameSymbol* length_name_symbol; 102 NameSymbol* null_name_symbol; 103 NameSymbol* Object_name_symbol; 104 NameSymbol* package_info_name_symbol; 105 NameSymbol* question_name_symbol; 106 NameSymbol* serialPersistentFields_name_symbol; 107 NameSymbol* serialVersionUID_name_symbol; 108 NameSymbol* this_name_symbol; 109 NameSymbol* true_name_symbol; 110 NameSymbol* val_name_symbol; 111 112 Utf8LiteralValue* ConstantValue_literal; 113 Utf8LiteralValue* Exceptions_literal; 114 Utf8LiteralValue* InnerClasses_literal; 115 Utf8LiteralValue* Synthetic_literal; 116 Utf8LiteralValue* Deprecated_literal; 117 Utf8LiteralValue* LineNumberTable_literal; 118 Utf8LiteralValue* LocalVariableTable_literal; 119 Utf8LiteralValue* Code_literal; 120 Utf8LiteralValue* SourceFile_literal; 121 Utf8LiteralValue* EnclosingMethod_literal; 122 123 // 124 // The primitive types. 125 // 126 TypeSymbol* byte_type; 127 TypeSymbol* short_type; 128 TypeSymbol* int_type; 129 TypeSymbol* long_type; 130 TypeSymbol* char_type; 131 TypeSymbol* float_type; 132 TypeSymbol* double_type; 133 TypeSymbol* boolean_type; 134 TypeSymbol* void_type; 135 TypeSymbol* null_type; 136 TypeSymbol* no_type; 137 138 // 139 // System package accessors. 140 // AnnotationPackage()141 inline PackageSymbol* AnnotationPackage() 142 { 143 if (! annotation_package) 144 annotation_package = ProcessPackage(US_java_SL_lang_SL_annotation); 145 return annotation_package; 146 } IoPackage()147 inline PackageSymbol* IoPackage() 148 { 149 if (! io_package) 150 io_package = ProcessPackage(US_java_SL_io); 151 return io_package; 152 } LangPackage()153 inline PackageSymbol* LangPackage() 154 { 155 assert(lang_package); 156 return lang_package; 157 } UtilPackage()158 inline PackageSymbol* UtilPackage() 159 { 160 if (! util_package) 161 util_package = ProcessPackage(US_java_SL_util); 162 return util_package; 163 } UnnamedPackage()164 inline PackageSymbol* UnnamedPackage() 165 { 166 assert(unnamed_package); 167 return unnamed_package; 168 } 169 170 // 171 // System type, method, and field accessors. Useful boilerplate macros 172 // reduce the chance for typos, but be sure to update Control::Control to 173 // initialize the field created by the macros to NULL. 174 // 175 176 // TYPE_ACCESSOR(classname, expression); 177 #define TYPE_ACCESSOR(type, package) \ 178 private: \ 179 TypeSymbol* type ## _type; \ 180 public: \ 181 inline TypeSymbol* type() \ 182 { \ 183 if (! type ## _type) \ 184 type ## _type = ProcessSystemType(package, #type); \ 185 return type ## _type; \ 186 } 187 188 // METHOD_ACCESSOR(class_methodname, expression, "name", "descriptor"); 189 #define METHOD_ACCESSOR(method, type, name, descriptor) \ 190 private: \ 191 MethodSymbol* method ## _method; \ 192 public: \ 193 inline MethodSymbol* method ## Method() \ 194 { \ 195 if (! method ## _method) \ 196 method ## _method = ProcessSystemMethod(type, name, descriptor); \ 197 return method ## _method; \ 198 } 199 200 // FIELD_ACCESSOR(classname, fieldname, "descriptor"); 201 #define FIELD_ACCESSOR(type, name, descriptor) \ 202 private: \ 203 VariableSymbol* type ## _ ## name ## _field; \ 204 public: \ 205 inline VariableSymbol* type ## _ ## name ## _Field() \ 206 { \ 207 if (! type ## _ ## name ## _field) \ 208 type ## _ ## name ## _field = \ 209 ProcessSystemField(type (), #name, descriptor); \ 210 return type ## _ ## name ## _field; \ 211 } 212 213 TYPE_ACCESSOR(Annotation, AnnotationPackage()); 214 TYPE_ACCESSOR(AssertionError, lang_package); 215 METHOD_ACCESSOR(AssertionError_Init, AssertionError(), "<init>", "()V"); 216 METHOD_ACCESSOR(AssertionError_InitWithChar, AssertionError(), 217 "<init>", "(C)V"); 218 METHOD_ACCESSOR(AssertionError_InitWithBoolean, AssertionError(), 219 "<init>", "(Z)V"); 220 METHOD_ACCESSOR(AssertionError_InitWithInt, AssertionError(), 221 "<init>", "(I)V"); 222 METHOD_ACCESSOR(AssertionError_InitWithLong, AssertionError(), 223 "<init>", "(J)V"); 224 METHOD_ACCESSOR(AssertionError_InitWithFloat, AssertionError(), 225 "<init>", "(F)V"); 226 METHOD_ACCESSOR(AssertionError_InitWithDouble, AssertionError(), 227 "<init>", "(D)V"); 228 METHOD_ACCESSOR(AssertionError_InitWithObject, AssertionError(), 229 "<init>", "(Ljava/lang/Object;)V"); 230 TYPE_ACCESSOR(Boolean, lang_package); 231 FIELD_ACCESSOR(Boolean, TYPE, "java/lang/Class"); 232 TYPE_ACCESSOR(Byte, lang_package); 233 FIELD_ACCESSOR(Byte, TYPE, "java/lang/Class"); 234 TYPE_ACCESSOR(Character, lang_package); 235 FIELD_ACCESSOR(Character, TYPE, "java/lang/Class"); 236 TYPE_ACCESSOR(Class, lang_package); 237 METHOD_ACCESSOR(Class_forName, Class(), 238 "forName", "(Ljava/lang/String;)Ljava/lang/Class;"); 239 METHOD_ACCESSOR(Class_getComponentType, Class(), 240 "getComponentType", "()Ljava/lang/Class;"); 241 METHOD_ACCESSOR(Class_desiredAssertionStatus, Class(), 242 "desiredAssertionStatus", "()Z"); 243 TYPE_ACCESSOR(ClassNotFoundException, lang_package); 244 TYPE_ACCESSOR(Cloneable, lang_package); 245 TYPE_ACCESSOR(Comparable, lang_package); 246 TYPE_ACCESSOR(Double, lang_package); 247 FIELD_ACCESSOR(Double, TYPE, "java/lang/Class"); 248 TYPE_ACCESSOR(ElementType, AnnotationPackage()); 249 FIELD_ACCESSOR(ElementType, TYPE, "java/lang/annotation/ElementType"); 250 FIELD_ACCESSOR(ElementType, FIELD, "java/lang/annotation/ElementType"); 251 FIELD_ACCESSOR(ElementType, METHOD, "java/lang/annotation/ElementType"); 252 FIELD_ACCESSOR(ElementType, PARAMETER, "java/lang/annotation/ElementType"); 253 FIELD_ACCESSOR(ElementType, CONSTRUCTOR, 254 "java/lang/annotation/ElementType"); 255 FIELD_ACCESSOR(ElementType, LOCAL_VARIABLE, 256 "java/lang/annotation/ElementType"); 257 FIELD_ACCESSOR(ElementType, ANNOTATION_TYPE, 258 "java/lang/annotation/ElementType"); 259 FIELD_ACCESSOR(ElementType, PACKAGE, "java/lang/annotation/ElementType"); 260 TYPE_ACCESSOR(Enum, lang_package); 261 METHOD_ACCESSOR(Enum_Init, Enum(), "<init>", "(Ljava/lang/String;I)V"); 262 METHOD_ACCESSOR(Enum_ordinal, Enum(), "ordinal", "()I"); 263 METHOD_ACCESSOR(Enum_valueOf, Enum(), "valueOf", 264 "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;"); 265 TYPE_ACCESSOR(Error, lang_package); 266 TYPE_ACCESSOR(Exception, lang_package); 267 TYPE_ACCESSOR(Float, lang_package); 268 FIELD_ACCESSOR(Float, TYPE, "java/lang/Class"); 269 TYPE_ACCESSOR(Integer, lang_package); 270 FIELD_ACCESSOR(Integer, TYPE, "java/lang/Class"); 271 TYPE_ACCESSOR(Iterable, lang_package); 272 METHOD_ACCESSOR(Iterable_iterator, Iterable(), 273 "iterator", "()Ljava/util/Iterator;"); 274 TYPE_ACCESSOR(Iterator, UtilPackage()); 275 METHOD_ACCESSOR(Iterator_hasNext, Iterator(), "hasNext", "()Z"); 276 METHOD_ACCESSOR(Iterator_next, Iterator(), "next", "()Ljava/lang/Object;"); 277 TYPE_ACCESSOR(Long, lang_package); 278 FIELD_ACCESSOR(Long, TYPE, "java/lang/Class"); 279 TYPE_ACCESSOR(NoClassDefFoundError, lang_package); 280 METHOD_ACCESSOR(NoClassDefFoundError_Init, NoClassDefFoundError(), 281 "<init>", "()V"); 282 METHOD_ACCESSOR(NoClassDefFoundError_InitString, NoClassDefFoundError(), 283 "<init>", "(Ljava/lang/String;)V"); 284 TYPE_ACCESSOR(Object, lang_package); 285 METHOD_ACCESSOR(Object_getClass, Object(), 286 "getClass", "()Ljava/lang/Class;"); 287 TYPE_ACCESSOR(Overrides, lang_package); 288 TYPE_ACCESSOR(Retention, AnnotationPackage()); 289 TYPE_ACCESSOR(RetentionPolicy, AnnotationPackage()); 290 FIELD_ACCESSOR(RetentionPolicy, SOURCE, 291 "java/lang/annotation/RetentionPolicy"); 292 FIELD_ACCESSOR(RetentionPolicy, CLASS, 293 "java/lang/annotation/RetentionPolicy"); 294 FIELD_ACCESSOR(RetentionPolicy, RUNTIME, 295 "java/lang/annotation/RetentionPolicy"); 296 TYPE_ACCESSOR(RuntimeException, lang_package); 297 TYPE_ACCESSOR(Serializable, IoPackage()); 298 TYPE_ACCESSOR(Short, lang_package); 299 FIELD_ACCESSOR(Short, TYPE, "java/lang/Class"); 300 TYPE_ACCESSOR(String, lang_package); 301 TYPE_ACCESSOR(StringBuffer, lang_package); 302 METHOD_ACCESSOR(StringBuffer_Init, StringBuffer(), "<init>", "()V"); 303 METHOD_ACCESSOR(StringBuffer_InitWithString, StringBuffer(), 304 "<init>", "(Ljava/lang/String;)V"); 305 METHOD_ACCESSOR(StringBuffer_toString, StringBuffer(), 306 "toString", "()Ljava/lang/String;"); 307 METHOD_ACCESSOR(StringBuffer_append_char, StringBuffer(), 308 "append", "(C)Ljava/lang/StringBuffer;"); 309 METHOD_ACCESSOR(StringBuffer_append_boolean, StringBuffer(), 310 "append", "(Z)Ljava/lang/StringBuffer;"); 311 METHOD_ACCESSOR(StringBuffer_append_int, StringBuffer(), 312 "append", "(I)Ljava/lang/StringBuffer;"); 313 METHOD_ACCESSOR(StringBuffer_append_long, StringBuffer(), 314 "append", "(J)Ljava/lang/StringBuffer;"); 315 METHOD_ACCESSOR(StringBuffer_append_float, StringBuffer(), 316 "append", "(F)Ljava/lang/StringBuffer;"); 317 METHOD_ACCESSOR(StringBuffer_append_double, StringBuffer(), 318 "append", "(D)Ljava/lang/StringBuffer;"); 319 METHOD_ACCESSOR(StringBuffer_append_string, StringBuffer(), 320 "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;"); 321 METHOD_ACCESSOR(StringBuffer_append_object, StringBuffer(), 322 "append", "(Ljava/lang/Object;)Ljava/lang/StringBuffer;"); 323 TYPE_ACCESSOR(StringBuilder, lang_package); 324 METHOD_ACCESSOR(StringBuilder_Init, StringBuilder(), "<init>", "()V"); 325 METHOD_ACCESSOR(StringBuilder_InitWithString, StringBuilder(), 326 "<init>", "(Ljava/lang/String;)V"); 327 METHOD_ACCESSOR(StringBuilder_toString, StringBuilder(), 328 "toString", "()Ljava/lang/String;"); 329 METHOD_ACCESSOR(StringBuilder_append_char, StringBuilder(), 330 "append", "(C)Ljava/lang/StringBuilder;"); 331 METHOD_ACCESSOR(StringBuilder_append_boolean, StringBuilder(), 332 "append", "(Z)Ljava/lang/StringBuilder;"); 333 METHOD_ACCESSOR(StringBuilder_append_int, StringBuilder(), 334 "append", "(I)Ljava/lang/StringBuilder;"); 335 METHOD_ACCESSOR(StringBuilder_append_long, StringBuilder(), 336 "append", "(J)Ljava/lang/StringBuilder;"); 337 METHOD_ACCESSOR(StringBuilder_append_float, StringBuilder(), 338 "append", "(F)Ljava/lang/StringBuilder;"); 339 METHOD_ACCESSOR(StringBuilder_append_double, StringBuilder(), 340 "append", "(D)Ljava/lang/StringBuilder;"); 341 METHOD_ACCESSOR(StringBuilder_append_string, StringBuilder(), 342 "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;"); 343 METHOD_ACCESSOR(StringBuilder_append_object, StringBuilder(), 344 "append", "(Ljava/lang/Object;)Ljava/lang/StringBuilder;"); 345 TYPE_ACCESSOR(Target, AnnotationPackage()); 346 TYPE_ACCESSOR(Throwable, lang_package); 347 METHOD_ACCESSOR(Throwable_getMessage, Throwable(), 348 "getMessage", "()Ljava/lang/String;"); 349 METHOD_ACCESSOR(Throwable_initCause, Throwable(), "initCause", 350 "(Ljava/lang/Throwable;)Ljava/lang/Throwable;"); 351 TYPE_ACCESSOR(Void, lang_package); 352 FIELD_ACCESSOR(Void, TYPE, "java/lang/Class"); 353 354 #undef TYPE_ACCESSOR 355 #undef METHOD_ACCESSOR 356 #undef FIELD_ACCESSOR 357 358 IntLiteralTable int_pool; 359 LongLiteralTable long_pool; 360 FloatLiteralTable float_pool; 361 DoubleLiteralTable double_pool; 362 Utf8LiteralTable Utf8_pool; 363 364 Control(char**, Option&); 365 ~Control(); 366 ConvertUnicodeToUtf8(const wchar_t * source)367 Utf8LiteralValue* ConvertUnicodeToUtf8(const wchar_t* source) 368 { 369 // Should be big enough for the worst case. 370 char* target = new char[wcslen(source) * 3 + 1]; 371 int length = ConvertUnicodeToUtf8(source, target); 372 Utf8LiteralValue* literal = Utf8_pool.FindOrInsert(target, length); 373 delete [] target; 374 return literal; 375 } 376 377 static int ConvertUtf8ToUnicode(wchar_t*, const char*, int); 378 ConvertUtf8ToUnicode(const char * source,int length)379 NameSymbol* ConvertUtf8ToUnicode(const char* source, int length) 380 { 381 wchar_t* name = new wchar_t[length + 1]; 382 int name_length = ConvertUtf8ToUnicode(name, source, length); 383 NameSymbol* name_symbol = FindOrInsertName(name, name_length); 384 delete [] name; 385 return name_symbol; 386 } 387 388 void FindPathsToDirectory(PackageSymbol*); 389 390 DirectoryEntry* FindInputFile(FileSymbol*); 391 void FindMoreRecentInputFiles(SymbolSet&); 392 void RemoveTrashedTypes(SymbolSet&); 393 void RereadDirectory(DirectorySymbol*); 394 void RereadDirectories(); 395 void ComputeRecompilationSet(TypeDependenceChecker&); 396 bool IncrementalRecompilation(); 397 398 // 399 // The one and only bad value constant. 400 // BadValue()401 LiteralValue* BadValue() { return &bad_value; } 402 403 // 404 // Note that only names are converted here and not literals, since 405 // no error can occur in a name. 406 // A literal is converted during the semantic pass so that an 407 // accurate diagnostic can be issued in case it is invalid. 408 // FindOrInsertName(const wchar_t * name,int len)409 NameSymbol* FindOrInsertName(const wchar_t* name, int len) 410 { 411 NameSymbol* name_symbol = name_table.FindOrInsertName(name, len); 412 if (! name_symbol -> Utf8_literal) 413 name_symbol -> Utf8_literal = 414 ConvertUnicodeToUtf8(name_symbol -> Name()); 415 return name_symbol; 416 } 417 418 // 419 // Make up a parameter name of the form $(num) and return its name symbol. 420 // MakeParameter(int num)421 NameSymbol* MakeParameter(int num) 422 { 423 IntToWstring value(num); 424 wchar_t str[13]; 425 str[0] = U_DOLLAR; // '$' 426 wcscpy(&str[1], value.String()); 427 return FindOrInsertName(str, value.Length() + 1); 428 } 429 430 // 431 // 432 // 433 static DirectorySymbol* GetOutputDirectory(FileSymbol*); 434 static FileSymbol* GetJavaFile(PackageSymbol*, const NameSymbol*); 435 static FileSymbol* GetFile(Control&, PackageSymbol*, const NameSymbol*); 436 static FileSymbol* GetFileFirst(Control&, PackageSymbol*, 437 const NameSymbol*); 438 static FileSymbol* GetFileBoth(Control&, PackageSymbol*, 439 const NameSymbol*); 440 441 PackageSymbol* FindOrInsertPackage(LexStream*, AstName*); 442 void ProcessPackageDeclaration(FileSymbol*, AstPackageDeclaration*); 443 void CleanUp(FileSymbol*); 444 IsSimpleIntegerValueType(const TypeSymbol * type)445 inline bool IsSimpleIntegerValueType(const TypeSymbol* type) 446 { 447 return type == byte_type || type == short_type || 448 type == int_type || type == char_type; 449 } 450 IsIntegral(const TypeSymbol * type)451 inline bool IsIntegral(const TypeSymbol* type) 452 { 453 return IsSimpleIntegerValueType(type) || type == long_type; 454 } 455 IsFloatingPoint(const TypeSymbol * type)456 inline bool IsFloatingPoint(const TypeSymbol* type) 457 { 458 return type == float_type || type == double_type; 459 } 460 IsNumeric(const TypeSymbol * type)461 inline bool IsNumeric(const TypeSymbol* type) 462 { 463 return IsIntegral(type) || IsFloatingPoint(type); 464 } 465 IsDoubleWordType(const TypeSymbol * type)466 inline bool IsDoubleWordType(const TypeSymbol* type) 467 { 468 return type == long_type || type == double_type; 469 } 470 IsPrimitive(const TypeSymbol * type)471 inline bool IsPrimitive(const TypeSymbol* type) 472 { 473 return IsNumeric(type) || type == boolean_type; 474 } 475 ProcessBadType(TypeSymbol * type_symbol)476 inline void ProcessBadType(TypeSymbol* type_symbol) 477 { 478 type_trash_bin.Next() = type_symbol; 479 } 480 481 void ProcessHeaders(FileSymbol*); 482 483 #ifdef JIKES_DEBUG 484 int input_files_processed, 485 class_files_read, 486 class_files_written, 487 line_count; 488 #endif // JIKES_DEBUG 489 490 PackageSymbol* ProcessPackage(const wchar_t*); 491 492 DirectorySymbol* FindSubdirectory(PathSymbol*, wchar_t*, int); 493 DirectorySymbol* ProcessSubdirectories(wchar_t*, int, bool); 494 495 private: 496 LiteralValue bad_value; 497 498 // 499 // Cache of system packages. lang and unnamed are always valid, because of 500 // ProcessUnnamedPackage and ProcessSystemInformation in system.cpp, the 501 // constructor initializes the rest to NULL in control.cpp; see accessor 502 // methods above for assignment. 503 // 504 PackageSymbol* annotation_package; 505 PackageSymbol* io_package; 506 PackageSymbol* lang_package; 507 PackageSymbol* util_package; 508 PackageSymbol* unnamed_package; 509 510 static int ConvertUnicodeToUtf8(const wchar_t*, char*); 511 NameSymbol* FindOrInsertSystemName(const char* name); 512 513 void ProcessGlobals(); 514 void ProcessUnnamedPackage(); 515 void ProcessPath(); 516 void ProcessBootClassPath(); 517 void ProcessExtDirs(); 518 void ProcessClassPath(); 519 void ProcessSourcePath(); 520 TypeSymbol* GetPrimitiveType(const char*, char); 521 void ProcessSystemInformation(); 522 TypeSymbol* ProcessSystemType(PackageSymbol*, const char*); 523 MethodSymbol* ProcessSystemMethod(TypeSymbol*, const char*, const char*); 524 VariableSymbol* ProcessSystemField(TypeSymbol*, const char*, const char*); 525 526 void ProcessFile(FileSymbol*); 527 void ProcessMembers(); 528 void CollectTypes(TypeSymbol*, Tuple<TypeSymbol*>&); 529 void ProcessBodies(TypeSymbol*); 530 void CheckForUnusedImports(Semantic *); 531 532 void ProcessNewInputFiles(SymbolSet&, char**); 533 534 FileSymbol* FindOrInsertJavaInputFile(DirectorySymbol*, NameSymbol*); 535 FileSymbol* FindOrInsertJavaInputFile(wchar_t*, int); 536 }; 537 538 #ifdef HAVE_JIKES_NAMESPACE 539 } // Close namespace Jikes block 540 #endif 541 542 #endif // control_INCLUDED 543 544