STDMETHODIMP ExtPackBaseWrap::COMGETTER(Revision)(ULONG *aRevision)
{
LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "ExtPackBase::getRevision", aRevision));
VirtualBoxBase::clearError();
HRESULT hrc;
try
{
CheckComArgOutPointerValidThrow(aRevision);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc()))
throw autoCaller.rc();
hrc = getRevision(aRevision);
}
catch (HRESULT hrc2)
{
hrc = hrc2;
}
catch (...)
{
hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
}
LogRelFlow(("{%p} %s: leave *aRevision=%RU32 hrc=%Rhrc\n", this, "ExtPackBase::getRevision", *aRevision, hrc));
return hrc;
}
void usage(char *prog){
char prog_version[100];
char revision[100];
char pp[] = "%";
getPROGversion(prog_version); // get version (ie 5.x.z)
getRevision(revision); // get revision
printf("\n");
printf("background %s(%s) - %s\n",prog_version,revision,__DATE__);
printf(" Runs a program in the background when resources are available\n\nUsage:\n\n");
printf(" %s",prog);
printf(" [-d delay time (s) -h -u max_usage -v] prog [arguments]\n\n");
printf("where\n\n");
printf(" -d dtime - wait dtime seconds before running prog in the background\n");
printf(" -debug - display debug messages\n");
printf(" -h - display this message\n");
#ifdef pp_LINUX
printf(" -hosts hostfiles - file containing a list of host names to run jobs on\n");
#endif
printf(" -m max - wait to run prog until memory usage is less than max (25-100%s)\n",pp);
#ifdef pp_LINUX
printf(" -p path - specify directory path to change to after ssh'ing to remote host\n");
#endif
printf(" -u max - wait to run prog until cpu usage is less than max (25-100%s)\n",pp);
printf(" -v - display version information\n");
printf(" prog - program to run in the background\n");
printf(" arguments - command line arguments of prog\n\n");
printf("Example:\n");
printf(" background -d 1.5 -u 50 prog arg1 arg2\n");
printf(" runs prog (with arguments arg1 and arg2) after 1.5 seconds\n and when the CPU usage drops below 50%s\n",pp);
}
STDMETHODIMP HostUSBDeviceFilterWrap::COMGETTER(Revision)(BSTR *aRevision)
{
LogRelFlow(("{%p} %s: enter aRevision=%p\n", this, "HostUSBDeviceFilter::getRevision", aRevision));
VirtualBoxBase::clearError();
HRESULT hrc;
try
{
CheckComArgOutPointerValidThrow(aRevision);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc()))
throw autoCaller.rc();
hrc = getRevision(BSTROutConverter(aRevision).str());
}
catch (HRESULT hrc2)
{
hrc = hrc2;
}
catch (...)
{
hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
}
LogRelFlow(("{%p} %s: leave *aRevision=%ls hrc=%Rhrc\n", this, "HostUSBDeviceFilter::getRevision", *aRevision, hrc));
return hrc;
}
OpenAB::PIMItem::Revisions EDSCalendarStorage::getRevisions(const OpenAB::PIMItem::IDs& ids)
{
OpenAB::PIMItem::Revisions revisions;
OpenAB::PIMItem::IDs::const_iterator it;
for (it = ids.begin(); it != ids.end(); ++it)
{
revisions.push_back(getRevision((*it)));
}
return revisions;
}
void laydata::TEDfile::getFHeader()
{
// Get the leading string
std::string _leadstr = getString();
if (TED_LEADSTRING != _leadstr) throw EXPTNreadTDT("Bad leading record");
// Get format revision
getRevision();
// Get file time stamps
getTime(/*timeCreated, timeSaved*/);
// checkIntegrity();
}
void version(void){
char smv_version[100];
char revision[100];
getPROGversion(smv_version); // get Smokeview version (ie 5.x.z)
getRevision(revision); // get revision
printf("\n");
printf("background\n\n");
printf("Version: %s\n",smv_version);
printf("Revision: %s\n",revision);
printf("Compile Date: %s\n",__DATE__);
}
std::string Version::getString()
{
std::ostringstream version;
version << CO_VERSION_MAJOR << '.' << CO_VERSION_MINOR << '.'
<< CO_VERSION_PATCH;
const std::string revision = getRevision();
if( revision != "0" )
version << '.' << revision;
return version.str();
}
std::string Version::getString()
{
std::ostringstream version;
version << EQ_VERSION_MAJOR << '.' << EQ_VERSION_MINOR;
if( EQ_VERSION_PATCH > 0 )
version << '.' << EQ_VERSION_PATCH;
const uint32_t revision = getRevision();
if( revision > 0 )
version << '.' << revision;
return version.str();
}
uint32_t Cap1188_touch::getDeviceInfo(void){
uint32_t data;
data = getProductID();
data <<= 8;
data |= getMFGID();
data <<= 8;
data |= getRevision();
data <<= 8;
data |= getVendorID();
return data;
}
svn_opt_revision_t FunctionArguments::getRevision
(
const char *name,
svn_opt_revision_t default_value
)
{
if( hasArg( name ) )
{
return getRevision( name );
}
else
{
return default_value;
}
}
void laydata::TEDfile::read() {
// Get the leading string
std::string _leadstr = getString();
if (TED_LEADSTRING != _leadstr) throw EXPTNreadTDT();
// Get format revision
getRevision();
// Get file time stamps
getTime();
// checkIntegrity();
if (tedf_DESIGN != getByte()) throw EXPTNreadTDT();
std::string name = getString();
real DBU = getReal();
real UU = getReal();
tell_log(console::MT_DESIGNNAME, name.c_str());
_design = new tdtdesign(name,_created, _lastUpdated, DBU,UU);
_design->read(this);
//Design end marker is read already in tdtdesign so don't search it here
//byte designend = getByte();
}
svn_opt_revision_t FunctionArguments::getRevision
(
const char *name,
svn_opt_revision_kind default_value
)
{
if( hasArg( name ) )
{
return getRevision( name );
}
else
{
svn_opt_revision_t revision;
revision.kind = default_value;
if( revision.kind == svn_opt_revision_number )
revision.value.number = 1;
return revision;
}
}
void version(void){
char smv_version[100];
char revision[100];
getPROGversion(smv_version); // get Smokeview version (ie 5.x.z)
getRevision(revision); // get revision
PRINTF("\n");
PRINTF("Smokediff\n\n");
PRINTF("Version: %s\n",smv_version);
PRINTF("Revision: %s\n",revision);
PRINTF("Compile Date: %s\n",__DATE__);
#ifdef X64
PRINTF("Platform: WIN64\n");
#endif
#ifdef WIN32
#ifndef X64
PRINTF("Platform: WIN32\n");
#endif
#endif
#ifndef pp_OSX64
#ifdef pp_OSX
PRINTF("Platform: OSX\n");
#endif
#endif
#ifdef pp_OSX64
PRINTF("Platform: OSX64\n");
#endif
#ifndef pp_LINUX64
#ifdef pp_LINUX
PRINTF("Platform: LINUX\n");
#endif
#endif
#ifdef pp_LINUX64
PRINTF("Platform: LINUX64\n");
#endif
}
int optionInit(int argc, const char **argv)
{
int i;
char *s;
opt_mod = "a";
strcpy(opt_dir, "");
strcpy(opt_logFile, "");
strcpy(opt_7z, CMD_7Z);
strcpy(opt_SourcesPath, "");
if ((s = getenv(SOURCES_ENV)))
strcpy(opt_SourcesPath, s);
revinfo.rev = getRevision(NULL, 1);
revinfo.range = DEF_RANGE;
revinfo.buildrev = getTBRevision(opt_dir);
l2l_dbg(1, "Trunk build revision: %d\n", revinfo.buildrev);
strcpy(opt_scanned, "");
//The user introduced "log2lines.exe" or "log2lines.exe /?"
//Let's help the user
if ((argc == 1) ||
((argc == 2) && (argv[1][0] == '/') && (argv[1][1] == '?')))
{
opt_help++;
usage(1);
return -1;
}
for (i = 1; i < argc; i++)
{
if ((argv[i][0] == '-') && (i+1 < argc))
{
//Because these arguments can contain spaces we cant use getopt(), a known bug:
switch (argv[i][1])
{
case 'd':
strcpy(opt_dir, argv[i+1]);
break;
case 'L':
opt_mod = "w";
//fall through
case 'l':
strcpy(opt_logFile, argv[i+1]);
break;
case 'P':
free(opt_Pipe);
opt_Pipe = malloc(LINESIZE);
strcpy(opt_Pipe, argv[i+1]);
break;
case 'z':
strcpy(opt_7z, argv[i+1]);
break;
}
}
strcat(opt_scanned, argv[i]);
strcat(opt_scanned, " ");
}
l2l_dbg(4,"opt_scanned=[%s]\n",opt_scanned);
return 0;
}
/**
* NOTE: The technique is not the same as that used in TinyVM.
* The return value indicates the impact of the call on the VM
* system. EXEC_CONTINUE normal return the system should return to the return
* address provided by the VM. EXEC_RUN The call has modified the value of
* VM PC and this should be used to restart execution. EXEC_RETRY The call
* needs to be re-tried (typically for a GC failure), all global state
* should be left intact, the PC has been set appropriately.
*
*/
int dispatch_native(TWOBYTES signature, STACKWORD * paramBase)
{
STACKWORD p0 = paramBase[0];
switch (signature) {
case wait_4_5V:
return monitor_wait((Object *) word2ptr(p0), 0);
case wait_4J_5V:
return monitor_wait((Object *) word2ptr(p0), ((int)paramBase[1] > 0 ? 0x7fffffff : paramBase[2]));
case notify_4_5V:
return monitor_notify((Object *) word2ptr(p0), false);
case notifyAll_4_5V:
return monitor_notify((Object *) word2ptr(p0), true);
case start_4_5V:
// Create thread, allow for instruction restart
return init_thread((Thread *) word2ptr(p0));
case yield_4_5V:
schedule_request(REQUEST_SWITCH_THREAD);
break;
case sleep_4J_5V:
sleep_thread(((int)p0 > 0 ? 0x7fffffff : paramBase[1]));
schedule_request(REQUEST_SWITCH_THREAD);
break;
case getPriority_4_5I:
push_word(get_thread_priority((Thread *) word2ptr(p0)));
break;
case setPriority_4I_5V:
{
STACKWORD p = (STACKWORD) paramBase[1];
if (p > MAX_PRIORITY || p < MIN_PRIORITY)
return throw_new_exception(JAVA_LANG_ILLEGALARGUMENTEXCEPTION);
else
set_thread_priority((Thread *) word2ptr(p0), p);
}
break;
case currentThread_4_5Ljava_3lang_3Thread_2:
push_ref(ptr2ref(currentThread));
break;
case interrupt_4_5V:
interrupt_thread((Thread *) word2ptr(p0));
break;
case interrupted_4_5Z:
{
JBYTE i = currentThread->interruptState != INTERRUPT_CLEARED;
currentThread->interruptState = INTERRUPT_CLEARED;
push_word(i);
}
break;
case isInterrupted_4_5Z:
push_word(((Thread *) word2ptr(p0))->interruptState
!= INTERRUPT_CLEARED);
break;
case join_4_5V:
join_thread((Thread *) word2ptr(p0), 0);
break;
case join_4J_5V:
join_thread((Thread *) word2obj(p0), paramBase[2]);
break;
case halt_4I_5V:
schedule_request(REQUEST_EXIT);
break;
case shutdown_4_5V:
shutdown_program(false);
break;
case currentTimeMillis_4_5J:
push_word(0);
push_word(systick_get_ms());
break;
case readSensorValue_4I_5I:
push_word(sp_read(p0, SP_ANA));
break;
case setPowerTypeById_4II_5V:
sp_set_power(p0, paramBase[1]);
break;
case freeMemory_4_5J:
push_word(0);
push_word(getHeapFree());
break;
case totalMemory_4_5J:
push_word(0);
push_word(getHeapSize());
break;
case floatToRawIntBits_4F_5I: // Fall through
case intBitsToFloat_4I_5F:
push_word(p0);
break;
case doubleToRawLongBits_4D_5J: // Fall through
case longBitsToDouble_4J_5D:
push_word(p0);
push_word(paramBase[1]);
break;
case drawString_4Ljava_3lang_3String_2II_5V:
{
String *p = (String *)word2obj(p0);
Object *charArray;
if (!p) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
if (!charArray) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
display_goto_xy(paramBase[1], paramBase[2]);
display_jstring(p);
}
break;
case drawInt_4III_5V:
display_goto_xy(paramBase[1], paramBase[2]);
display_int(p0, 0);
break;
case drawInt_4IIII_5V:
display_goto_xy(paramBase[2], paramBase[3]);
display_int(p0, paramBase[1]);
break;
case asyncRefresh_4_5V:
display_update();
break;
case clear_4_5V:
display_clear(0);
break;
case getDisplay_4_5_1B:
push_word(display_get_array());
break;
case setAutoRefreshPeriod_4I_5I:
push_word(display_set_auto_update_period(p0));
break;
case getRefreshCompleteTime_4_5I:
push_word(display_get_update_complete_time());
break;
case bitBlt_4_1BIIII_1BIIIIIII_5V:
{
Object *src = word2ptr(p0);
Object *dst = word2ptr(paramBase[5]);
display_bitblt((byte *)(src != NULL ?jbyte_array(src):NULL), paramBase[1], paramBase[2], paramBase[3], paramBase[4], (byte *)(dst!=NULL?jbyte_array(dst):NULL), paramBase[6], paramBase[7], paramBase[8], paramBase[9], paramBase[10], paramBase[11], paramBase[12]);
break;
}
case getSystemFont_4_5_1B:
push_word(display_get_font());
break;
case setContrast_4I_5V:
nxt_lcd_set_pot(p0);
break;
case getBatteryStatus_4_5I:
push_word(battery_voltage());
break;
case getButtons_4_5I:
push_word(buttons_get());
break;
case getTachoCountById_4I_5I:
push_word(nxt_motor_get_count(p0));
break;
case controlMotorById_4III_5V:
nxt_motor_set_speed(p0, paramBase[1], paramBase[2]);
break;
case resetTachoCountById_4I_5V:
nxt_motor_set_count(p0, 0);
break;
case i2cEnableById_4II_5V:
if (i2c_enable(p0, paramBase[1]) == 0)
return EXEC_RETRY;
else
break;
case i2cDisableById_4I_5V:
i2c_disable(p0);
break;
case i2cStatusById_4I_5I:
push_word(i2c_status(p0));
break;
case i2cStartById_4II_1BIII_5I:
{
Object *p = word2obj(paramBase[2]);
JBYTE *byteArray = p ? jbyte_array(p) + paramBase[3] : NULL;
push_word(i2c_start(p0,
paramBase[1],
(U8 *)byteArray,
paramBase[4],
paramBase[5]));
}
break;
case i2cCompleteById_4I_1BII_5I:
{
Object *p = word2ptr(paramBase[1]);
JBYTE *byteArray = p ? jbyte_array(p) + paramBase[2] : NULL;
push_word(i2c_complete(p0,
(U8 *)byteArray,
paramBase[3]));
}
break;
case playFreq_4III_5V:
sound_freq(p0,paramBase[1], paramBase[2]);
break;
case btGetBC4CmdMode_4_5I:
push_word(bt_get_mode());
break;
case btSetArmCmdMode_4I_5V:
if (p0 == 0) bt_set_arm7_cmd();
else bt_clear_arm7_cmd();
break;
case btSetResetLow_4_5V:
bt_set_reset_low();
break;
case btSetResetHigh_4_5V:
bt_set_reset_high();
break;
case btWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(bt_write(byteArray, paramBase[1], paramBase[2]));
}
break;
case btRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(bt_read(byteArray, paramBase[1], paramBase[2]));
}
break;
case btPending_4_5I:
{
push_word(bt_event_check(0xffffffff));
}
break;
case btEnable_4_5V:
if (bt_enable() == 0)
return EXEC_RETRY;
else
break;
case btDisable_4_5V:
bt_disable();
break;
case usbRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(udp_read(byteArray,paramBase[1], paramBase[2]));
}
break;
case usbWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(udp_write(byteArray,paramBase[1], paramBase[2]));
}
break;
case usbStatus_4_5I:
{
push_word(udp_event_check(0xffffffff));
}
break;
case usbEnable_4I_5V:
{
udp_enable(p0);
}
break;
case usbDisable_4_5V:
{
udp_disable();
}
break;
case usbReset_4_5V:
udp_reset();
break;
case usbSetSerialNo_4Ljava_3lang_3String_2_5V:
{
byte *p = word2ptr(p0);
int len;
Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
len = get_array_length(charArray);
udp_set_serialno((U8 *)jchar_array(charArray), len);
}
break;
case usbSetName_4Ljava_3lang_3String_2_5V:
{
byte *p = word2ptr(p0);
int len;
Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
len = get_array_length(charArray);
udp_set_name((U8 *)jchar_array(charArray), len);
}
break;
case flashWritePage_4_1BI_5I:
{
Object *p = word2ptr(p0);
unsigned long *intArray = (unsigned long *) jint_array(p);
push_word(flash_write_page(intArray,paramBase[1]));
}
break;
case flashReadPage_4_1BI_5I:
{
Object *p = word2ptr(p0);
unsigned long *intArray = (unsigned long *) jint_array(p);
push_word(flash_read_page(intArray,paramBase[1]));
}
break;
case flashExec_4II_5I:
push_word(run_program((byte *)(&FLASH_BASE[(p0*FLASH_PAGE_SIZE)]), paramBase[1]));
break;
case playSample_4IIIII_5V:
sound_play_sample(((unsigned char *) &FLASH_BASE[(p0*FLASH_PAGE_SIZE)]) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]);
break;
case playQueuedSample_4_1BIIII_5I:
push_word(sound_add_sample((U8 *)jbyte_array(word2obj(p0)) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]));
break;
case getTime_4_5I:
push_word(sound_get_time());
break;
case getDataAddress_4Ljava_3lang_3Object_2_5I:
if (is_array(word2obj(p0)))
push_word (ptr2word ((byte *) array_start(word2ptr(p0))));
else
push_word (ptr2word ((byte *) fields_start(word2ptr(p0))));
break;
case getObjectAddress_4Ljava_3lang_3Object_2_5I:
push_word(p0);
break;
case gc_4_5V:
// Restartable garbage collection
return garbage_collect();
case shutDown_4_5V:
shutdown(); // does not return
case boot_4_5V:
display_clear(1);
while (1) nxt_avr_firmware_update_mode(); // does not return
case arraycopy_4Ljava_3lang_3Object_2ILjava_3lang_3Object_2II_5V:
return arraycopy(word2ptr(p0), paramBase[1], word2ptr(paramBase[2]), paramBase[3], paramBase[4]);
case executeProgram_4I_5V:
// Exceute program, allow for instruction re-start
return execute_program(p0);
case setDebug_4_5V:
set_debug(word2ptr(p0));
break;
case eventOptions_4II_5I:
{
byte old = debugEventOptions[p0];
debugEventOptions[p0] = (byte)paramBase[1];
push_word(old);
}
break;
case suspendThread_4Ljava_3lang_3Object_2_5V:
suspend_thread(ref2ptr(p0));
break;
case resumeThread_4Ljava_3lang_3Object_2_5V:
resume_thread(ref2ptr(p0));
break;
case getProgramExecutionsCount_4_5I:
push_word(gProgramExecutions);
break;
case getFirmwareRevision_4_5I:
push_word((STACKWORD) getRevision());
break;
case getFirmwareRawVersion_4_5I:
push_word((STACKWORD) VERSION_NUMBER);
break;
case hsEnable_4II_5V:
{
if (hs_enable((int)p0, (int)paramBase[1]) == 0)
return EXEC_RETRY;
}
break;
case hsDisable_4_5V:
{
hs_disable();
}
break;
case hsWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(hs_write(byteArray, paramBase[1], paramBase[2]));
}
break;
case hsRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(hs_read(byteArray, paramBase[1], paramBase[2]));
}
break;
case hsPending_4_5I:
{
push_word(hs_pending());
}
break;
case hsSend_4BB_1BII_1C_5I:
{
Object *p = word2ptr(paramBase[2]);
U8 *data = (U8 *)jbyte_array(p);
p = word2ptr(paramBase[5]);
U16 *crc = (U16 *)jchar_array(p);
push_word(hs_send((U8) p0, (U8)paramBase[1], data, paramBase[3], paramBase[4], crc));
}
break;
case hsRecv_4_1BI_1CI_5I:
{
Object *p = word2ptr(p0);
U8 *data = (U8 *)jbyte_array(p);
p = word2ptr(paramBase[2]);
U16 *crc = (U16 *)jchar_array(p);
push_word(hs_recv(data, paramBase[1], crc, paramBase[3]));
}
break;
case getUserPages_4_5I:
push_word(FLASH_MAX_PAGES - flash_start_page);
break;
case setVMOptions_4I_5V:
gVMOptions = p0;
break;
case getVMOptions_4_5I:
push_word(gVMOptions);
break;
case isAssignable_4II_5Z:
push_word(is_assignable(p0, paramBase[1]));
break;
case cloneObject_4Ljava_3lang_3Object_2_5Ljava_3lang_3Object_2:
{
Object *newObj = clone((Object *)ref2obj(p0));
if (newObj == NULL) return EXEC_RETRY;
push_word(obj2ref(newObj));
}
break;
case memPeek_4III_5I:
push_word(mem_peek(p0, paramBase[1], paramBase[2]));
break;
case memCopy_4Ljava_3lang_3Object_2IIII_5V:
mem_copy(word2ptr(p0), paramBase[1], paramBase[2], paramBase[3], paramBase[4]);
break;
case memGetReference_4II_5Ljava_3lang_3Object_2:
push_word(mem_get_reference(p0, paramBase[1]));
break;
case setSensorPin_4III_5V:
sp_set(p0, paramBase[1], paramBase[2]);
break;
case getSensorPin_4II_5I:
push_word(sp_get(p0, paramBase[1]));
break;
case setSensorPinMode_4III_5V:
sp_set_mode(p0, paramBase[1], paramBase[2]);
break;
case readSensorPin_4II_5I:
push_word(sp_read(p0, paramBase[1]));
break;
case nanoTime_4_5J:
{
U64 ns = systick_get_ns();
push_word(ns >> 32);
push_word(ns);
}
break;
case createStackTrace_4Ljava_3lang_3Thread_2Ljava_3lang_3Object_2_5_1I:
{
Object *trace = create_stack_trace((Thread *)ref2obj(p0), ref2obj(paramBase[1]));
if (trace == NULL) return EXEC_RETRY;
push_word(obj2ref(trace));
}
break;
case registerEvent_4_5I:
push_word(register_event((NXTEvent *) ref2obj(p0)));
break;
case unregisterEvent_4_5I:
push_word(unregister_event((NXTEvent *) ref2obj(p0)));
break;
case changeEvent_4II_5I:
push_word(change_event((NXTEvent *) ref2obj(p0), paramBase[1], paramBase[2]));
break;
case isInitialized_4I_5Z:
push_word(is_initialized_idx(p0));
break;
case allocate_4II_5Ljava_3lang_3Object_2:
{
Object *allocated;
if(paramBase[1]>0){
allocated=new_single_array(p0,paramBase[1]);
}else{
allocated=new_object_for_class(p0);
}
if(allocated == NULL) return EXEC_RETRY;
push_word(obj2ref(allocated));
}
break;
case memPut_4IIII_5V:
store_word_ns((byte *)(memory_base[p0] + paramBase[1]), paramBase[2],paramBase[3]);
break;
case notifyEvent_4ILjava_3lang_3Thread_2_5Z:
push_word(debug_event(paramBase[1], NULL, (Thread*) ref2obj(paramBase[2]), 0, 0, 0, 0));
break;
case setThreadRequest_4Ljava_3lang_3Thread_2Llejos_3nxt_3debug_3SteppingRequest_2_5V:
{
Thread *th = (Thread*) ref2obj(p0);
th->debugData = (REFERENCE) paramBase[1];
// currently we only get stepping requests
if(paramBase[1])
th->flags |= THREAD_STEPPING;
else
th->flags &= ~THREAD_STEPPING;
}
break;
case isStepping_4Ljava_3lang_3Thread_2_5Z:
{
Thread *th = (Thread*) ref2obj(p0);
push_word(is_stepping(th));
}
break;
case setBreakpointList_4_1Llejos_3nxt_3debug_3Breakpoint_2I_5V:
breakpoint_set_list((Breakpoint**) array_start(p0), paramBase[1]);
break;
case enableBreakpoint_4Llejos_3nxt_3debug_3Breakpoint_2Z_5V:
breakpoint_enable((Breakpoint*) word2ptr(p0), (boolean) paramBase[1]);
break;
case firmwareExceptionHandler_4Ljava_3lang_3Throwable_2II_5V:
firmware_exception_handler((Throwable *)p0, paramBase[1], paramBase[2]);
break;
case exitThread_4_5V:
currentThread->state = DEAD;
schedule_request(REQUEST_SWITCH_THREAD);
break;
case updateThreadFlags_4Ljava_3lang_3Thread_2II_5I:
((Thread *)p0)->flags |= paramBase[1];
((Thread *)p0)->flags &= ~paramBase[2];
//printf("m %x %d\n", p0, ((Thread *)p0)->flags);
push_word(((Thread *)p0)->flags);
break;
default:
return throw_new_exception(JAVA_LANG_NOSUCHMETHODERROR);
}
return EXEC_CONTINUE;
}
void usage(char *prog){
char smv_version[100];
char buffer[1000];
char revision[256];
getPROGversion(smv_version); // get Smokeview version (ie 5.x.z)
getRevision(revision); // get svn revision number
PRINTF("\n");
PRINTF(" smokezip %s(%s) - %s\n\n",smv_version,revision,__DATE__);
PRINTF(" Compress FDS data files\n\n");
PRINTF(" %s [options] casename\n\n",get_basefilename(buffer,prog));
PRINTF(" casename - Smokeview .smv file for case to be compressed\n\n");
PRINTF("options:\n");
PRINTF(" -c - cleans or removes all compressed files\n");
#ifdef pp_THREAD
PRINTF(" -t nthread - Compress nthread files at a time (up to %i)\n",NTHREADS_MAX);
#endif
PRINTF("overwrite options:\n");
PRINTF(" -f - overwrites all compressed files\n");
PRINTF(" -2 - overwrites 2d slice compressed files\n");
PRINTF(" -3 - overwrites 3d smoke files\n");
PRINTF(" -b - overwrites boundary compressed files\n");
#ifdef pp_PLOT3D
PRINTF(" -p - overwrites PLOT3D files\n");
#endif
#ifdef pp_PART2
PRINTF(" -P - overwrites particle files\n");
#endif
#ifdef pp_PART
PRINTF(" -part2iso - generate isosurfaces from particle data\n");
#endif
PRINTF("bound options:\n");
PRINTF(" -bounds - estimate data bounds for all file types\n");
PRINTF(" -bb - estimate data bounds for boundary files\n");
PRINTF(" -bs - estimate data bounds for slice files\n");
PRINTF(" -no_chop - do not chop or truncate slice data. Smokezip compresses\n");
PRINTF(" slice data truncating data above and below chop values\n");
PRINTF(" specified in the .ini file\n");
#ifdef pp_PLOT3D
PRINTF(" -bp - estimate data bounds for plot3d files\n");
#endif
#ifdef pp_PART2
PRINTF(" -bP - estimate data bounds for particle files\n");
#endif
PRINTF("compress options:\n");
PRINTF(" -n3 - do not compress 3d smoke files\n");
PRINTF(" -nb - do not compress boundary files\n");
#ifdef pp_PLOT3D
PRINTF(" -np - do not compress PLOT3D files\n");
#endif
PRINTF(" -ns - do not compress slice files\n");
#ifdef pp_PART2
PRINTF(" -nP - do not compress particle files\n");
PRINTF(" -yP - compress particle files\n");
#endif
PRINTF("output options:\n");
PRINTF(" -auto - compress only files that are auto-loaded by Smokeview\n");
PRINTF(" -d destdir - copies compressed files (and files needed by Smokeview\n");
PRINTF(" to view the case) to the directory destdir\n");
PRINTF(" -s GLOBsourcedir - specifies directory containing source files\n");
PRINTF(" -demo - Creates the files (compressed and .svd ) needed by the\n");
PRINTF(" Smokeview demonstrator mode. Compresses files that are autoloaded, \n");
PRINTF(" uses (20.0,620.0) and (0.0,0.23) for temperature and oxygen bounds\n");
PRINTF(" and creates the .svd file which activates the Smokeview demonstrator\n");
PRINTF(" mode.\n");
PRINTF(" -skip skipval - skip frames when compressing files\n\n");
PRINTF(" -h - display this message\n\n");
}
void processFile(char* name) {
stringNode* node;
if (node = table.lookup(name)) {
if (!node->isMarked()) {
node->mark();
File localfile(name);
if (node->version == remove_keyword) {
if (verbose) {
fprintf(stderr, "File %s keyword is %s; removing\n",
name, node->version);
}
localfile.remove();
} else {
File basefile(dirs.baseline, dirs.subdir->path, localfile.path);
if (node->version == copy_keyword) {
if (verbose) {
fprintf(stderr, "File %s keyword is %s; copying if outdated\n",
name, node->version);
}
localfile.becomeIfOutdated(basefile, save);
} else {
// The file must have a revision
char* revision;
switch (getRevision(localfile.path, &revision)) {
case GOT_REVISION:
if (verbose) {
fprintf(stderr,
"Testing revisions of %s:\n"
" local: \"%s\"; baseline: \"%s\"...",
localfile.path, revision, node->version);
}
char* version;
if (forced_revision()) {
version = forced_revision_number ?
forced_revision_number :
basefile.getRevisionFromDate(forced_revision_date);
} else version = node->version;
switch (cmpRevisions(revision, version)) {
case EQUAL:
if (verbose) {
fprintf(stderr, "same; no action.\n");
}
break;
case LESS_THAN:
{
if (verbose) {
fprintf(stderr, "revision is behind; merge.\n");
}
File rcsfile(dirs.baseline, dirs.subdir->path, "RCS",
localfile.path);
if (forced_revision()) {
File tempfile("forced_mergefile.tmp");
char line[LINE_LENGTH];
sprintf(line, "co -q -p%s %s,v > %s",
version, rcsfile.path, tempfile.path);
if (execute(line)) {
tempfile.un_link();
exit(-1);
}
localfile.merge(tempfile, rcsfile, revision, version);
tempfile.un_link();
} else {
localfile.merge(basefile, rcsfile, revision, version);
}
}
break;
case GREATER_THAN:
if (verbose) {
fprintf(stderr, "\n");
}
fprintf(stderr, "%s has a newer revision number than baseline.\n",
localfile.path);
localfile.becomeIfConfirmed(basefile, 1);
break;
case FAILED:
if (verbose) {
fprintf(stderr, "\n");
}
fprintf(stderr,
"%s has a conflicting revision number with baseline.\n",
localfile.path);
localfile.becomeIfConfirmed(basefile, 1);
break;
default:
fprintf(stderr, "unexpected cmpRevisions result");
exit(-1);
}
break;
case NO_REVISION:
if (strcmp(node->version, "none") == 0) {
// baseline has no revision; copy if outdated
if (verbose) {
fprintf(stderr,
"%s has no revision number; copying if outdated\n",
localfile.path);
}
localfile.becomeIfOutdated(basefile, 1);
} else {
// baseline does have a revision num, but local file doesn't;
// ask!
fprintf(stderr,
"%s has no revision number (baseline's is %s).\n",
localfile.path, node->version);
localfile.becomeIfConfirmed(basefile, 1);
}
break;
default:
fprintf(stderr, "getRevision failed on %s\n", name);
localfile.becomeIfConfirmed(basefile, 1);
break;
}
}
}
} else {
if (verbose) {
fprintf(stderr, "File %s is marked; ignoring\n", name);
}
}
} else {
if (verbose) {
fprintf(stderr, "File %s not found in table; ignoring\n", name);
}
}
}
/** True if this addon needs to be updated. */
bool needsUpdate() const
{
return m_installed && getInstalledRevision() < getRevision();
} // needsUpdate
