int main(int argc, char** argv) { int maximumValue = 0, maximumWeight = 0, noOfItems = 0; int binaryString[MAXITEMS], optimalList[MAXITEMS]; int i = 0; item items[MAXITEMS]; //if a file has been specified. if (argc > 1) { readFromFile(argv[1], &maximumWeight, &noOfItems, items); } //no file specified. else { readFromConsole(&maximumWeight, &noOfItems, items); } //call the recursive function to enumerate all possibilities. enumItemSubset(0, binaryString, noOfItems, items, maximumWeight, &maximumValue, optimalList); //Print the output. printf("%d", maximumValue); for (i = 0; i < noOfItems; i++) { if (optimalList[i]) { printf(" %s", items[i].name); } } return (EXIT_SUCCESS); }
/* * Execute the specified native method. Return true if the method * is executed, false if it is rolled back for garbage collection. */ int executeNativeMethod(Ref target, Ref method, int offset) { int magic = getInt(method, METHOD_MAGIC); if (magic == 0) { printf("Native method not supported\n"); debugTrace(); exit(1); } switch (magic) { // print a debug message case MAGIC_RUNTIME_CORE_DEBUG: debugLine(popRef()); pc += offset; break; // execute the given static method case MAGIC_RUNTIME_CORE_EXECUTE_STATIC: { Ref staticMethod = popRef(); if (staticMethod == NULL) { throwException(CORE_THROW_NULL_POINTER); return; } Ref owner = getRef(staticMethod, ENTRY_OWNER); if (!executeMethod(owner, staticMethod, offset)) { // restore stack if rolled back for gc pushRef(staticMethod); } } break; // return the current frame case MAGIC_RUNTIME_FRAME_CURRENT: pushRef(frame); pc += offset; break; // return the core object case MAGIC_RUNTIME_CORE_GET: pushRef(core); pc += offset; break; // create a statics object case MAGIC_RUNTIME_STATICS_CREATE: { // allocate space for statics object Ref type = popRef(); Int numStaticFields = getInt(type, TYPE_STATIC_FIELD_COUNT); Int numWords = STATICS_FIELDS + numStaticFields; Ref statics = allocate(numWords, HEADER_STATIC_FIELDS); if (statics == NULL) { pushRef(type); // restore stack return; // rollback, gc done } // initialise statics object and set in type object int hash = (char*) statics - (char*) core; setInt(statics, OBJECT_HASHCODE, hash); Ref staticsType = getRef(core, CORE_STATICS_TYPE); setRef(statics, OBJECT_TYPE, staticsType); Ref map = getRef(type, TYPE_STATIC_MAP); setRef(statics, STATICS_MAP, map); setRef(type, TYPE_STATICS, statics); } pc += offset; break; // read the type from a class case MAGIC_RUNTIME_CORE_GET_TYPE: { Ref class = popRef(); // type is first field in class... Ref type = getRef(class, OBJECT_FIELDS); pushRef(type); } pc += offset; break; // put system to sleep to avoid wasting processor time while idle case MAGIC_RUNTIME_IDLE_SLEEP: idleSleep(); pc += offset; break; // return the currently executing thread case MAGIC_RUNTIME_THREAD_CURRENT: pushRef(thread); pc += offset; break; // start a new thread case MAGIC_RUNTIME_THREAD_START_HOOK: startNewThread(offset); break; // return an object's class case MAGIC_JAVA_OBJECT_GET_CLASS: { Ref obj = popRef(); Ref type = getRef(obj, OBJECT_TYPE); Ref peer = getRef(type, TYPE_PEER); pushRef(peer); } pc += offset; break; // set system output stream case MAGIC_JAVA_SYSTEM_SET_OUT: { Ref arg = popRef(); Ref type = getRef(method, ENTRY_OWNER); Ref statics = getRef(type, TYPE_STATICS); setRef(statics, STATICS_FIELDS + SYSTEM_OUT, arg); } pc += offset; break; // set system error stream case MAGIC_JAVA_SYSTEM_SET_ERR: { Ref arg = popRef(); Ref type = getRef(method, ENTRY_OWNER); Ref statics = getRef(type, TYPE_STATICS); setRef(statics, STATICS_FIELDS + SYSTEM_ERR, arg); } pc += offset; break; // set system input stream case MAGIC_JAVA_SYSTEM_SET_IN: { Ref arg = popRef(); Ref type = getRef(method, ENTRY_OWNER); Ref statics = getRef(type, TYPE_STATICS); setRef(statics, STATICS_FIELDS + SYSTEM_IN, arg); } pc += offset; break; // read an ascii character from the console case MAGIC_TEST_READ_FROM_CONSOLE: { char c = readFromConsole(); pushInt(c); } pc += offset; break; // write an ascii character to the console case MAGIC_TEST_WRITE_TO_CONSOLE: { char c = popInt() & 0xFF; printf("%c", c); } pc += offset; break; // read a byte from the floppy drive case MAGIC_TEST_READ_FROM_FLOPPY: { Int pos = popInt(); pushInt(readFromFloppy(pos)); } pc += offset; break; // magic id not recognised default: printf("Invalid magic method id: %d\n", magic); exit(1); break; } }