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;
}
}
