bool EncryptedStore::openWrite(const QString& name)
{
Q_D(KOdfStore);
if (bad())
return false;
if (isToBeEncrypted(name)) {
// Encrypted files will be compressed by this class and should be stored in the zip as not compressed
m_pZip->setCompression(KZip::NoCompression);
} else {
m_pZip->setCompression(KZip::DeflateCompression);
}
d->stream = new QBuffer();
(static_cast< QBuffer* >(d->stream))->open(QIODevice::WriteOnly);
if (name == MANIFEST_FILE)
return true;
return m_pZip->prepareWriting(name, "", "", 0);
}
bool Foam::Istream::getBack(token& t)
{
if (bad())
{
FatalIOErrorInFunction(*this)
<< "Attempt to get back from bad stream"
<< exit(FatalIOError);
}
else if (putBack_)
{
t = putBackToken_;
putBack_ = false;
return true;
}
return false;
}
void control_transfer(usb_dev_handle *dev, const char *pquestion) {
int r,i;
char question[reqIntLen];
memcpy(question, pquestion, sizeof question);
r = usb_control_msg(dev, 0x21, 0x09, 0x0200, 0x01, (char *) question, reqIntLen, timeout);
if( r < 0 )
{
perror("USB control write"); bad("USB write failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",question[i] & 0xFF);
printf("\n");
}
}
void interrupt_read(usb_dev_handle *dev) {
int r,i;
unsigned char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i] & 0xFF);
printf("\n");
}
}
float interrupt_read_temperature(usb_dev_handle *dev) {
int r,i;
unsigned char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, (char*)answer, reqIntLen, timeout);
if (r != reqIntLen) {
perror("USB interrupt read3"); bad("USB read failed");
}
if (debug) {
for (i=0; i < reqIntLen; i++) {
printf("%02x ", answer[i] & 0xFF);
}
printf("\n");
}
/* Temperature in C is a 16-bit signed fixed-point number, big-endian */
return (float)(signed char)answer[tempOffset] + answer[tempOffset+1] / 256.0f;
}
// Keep the put back token
void Istream::putBack(const token& t)
{
if (bad())
{
FatalIOErrorIn("void Istream::putBack(const token& t)", *this)
<< "Attempt to put back onto bad stream"
<< exit(FatalIOError);
}
else if (putBack_)
{
FatalIOErrorIn("void Istream::putBack(const token& t)", *this)
<< "Attempt to put back another token"
<< exit(FatalIOError);
}
else
{
putBackToken_ = t;
putBack_ = true;
}
}
void example_result()
{
auto result01 = open_for_reading("/dev/null");
assert(result01.ok());
assert(result01.value() != nullptr);
assert(fclose(result01.take()) == 0);
(void) result01;
auto result02 = open_for_reading("/dev/mem");
assert(!result02.ok());
assert(result02.bad());
assert(result02.error() == EACCES);
(void) result02;
assert(divide(1, 1).ok());
assert(divide(1, 1).value() == 1);
assert(divide(1, 1).take() == 1);
assert(!divide(1, 0).ok());
assert(divide(1, 0).take_or(1) == 1);
assert(divide(1, 0).error() == "division by zero");
}
// Set t to the put back token if there is one and return true,
// otherwise return false
bool Istream::getBack(token& t)
{
if (bad())
{
FatalIOErrorIn("void Istream::getBack(token& t)", *this)
<< "Attempt to get back from bad stream"
<< exit(FatalIOError);
return false;
}
else if (putBack_)
{
t = putBackToken_;
putBack_ = false;
return true;
}
else
{
return false;
}
}
void interrupt_transfer(usb_dev_handle *dev) {
int r,i;
char answer[reqIntLen];
char question[reqIntLen];
for (i=0;i<reqIntLen; i++) question[i]=i;
r = usb_interrupt_write(dev, endpoint_Int_out, question, reqIntLen, timeout);
if( r < 0 )
{
r = usb_interrupt_read(dev, endpoint_Int_in, answer, reqIntLen, timeout);
}
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%i, %i, \n",question[i],answer[i]);
}
usb_release_interface(dev, 0);
}
void VESPERS2DScanConfigurationView::axesAcceptable()
{
QPalette good(this->palette());
QPalette bad(good);
bad.setColor(QPalette::Base, Qt::red);
AMScanAxisRegion *region = configuration_->scanAxisAt(0)->regionAt(0);
if (double(region->regionStart()) < double(region->regionEnd()) && double(region->regionStep()) > 0)
hStep_->setPalette(good);
else
hStep_->setPalette(bad);
region = configuration_->scanAxisAt(1)->regionAt(0);
if (double(region->regionStart()) < double(region->regionEnd()) && double(region->regionStep()) > 0)
vStep_->setPalette(good);
else
vStep_->setPalette(bad);
}
int
sdbm_delete(register DBM *db, datum key)
{
if (db == NULL || bad(key))
return errno = EINVAL, -1;
if (sdbm_rdonly(db))
return errno = EPERM, -1;
if (getpage(db, exhash(key))) {
if (!delpair(db->pagbuf, key))
return -1;
/*
* update the page file
*/
if (lseek(db->pagf, OFF_PAG(db->pagbno), SEEK_SET) < 0
|| write(db->pagf, db->pagbuf, PBLKSIZ) < 0)
return ioerr(db), -1;
return 0;
}
return ioerr(db), -1;
}
void interrupt_read_temperatura(usb_dev_handle *dev, float *tempC) {
int r,i, temperature;
unsigned char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i] & 0xFF);
printf("\n");
}
temperature = (answer[3] & 0xFF) + (answer[2] << 8);
temperature += calibration;
*tempC = temperature * (125.0 / 32000.0);
}
bool good() const {
return !bad();
}
int main(int argc, char * argv[])
{
bad();
return 0;
}
namespace lifetime {
constexpr int &&id(int &&n) { return static_cast<int&&>(n); }
constexpr int &&dead() { return id(0); } // expected-note {{temporary created here}}
constexpr int bad() { int &&n = dead(); n = 1; return n; } // expected-note {{assignment to temporary whose lifetime has ended}}
static_assert(bad(), ""); // expected-error {{constant expression}} expected-note {{in call}}
}
int auth_userdb_passwd(const char *service,
const char *uid,
const char *opwd_buf,
const char *npwd_buf)
{
char *opwd;
char *npwd;
int rc;
int hmac_flag=0;
if (bad(uid) ||
bad(service) ||
bad(opwd_buf) ||
bad(npwd_buf) ||
strchr(uid, '/'))
{
errno=EPERM;
return (1);
}
#if HAVE_HMACLIB
if (strncmp(service, "hmac-", 5) == 0)
{
opwd=hmacpw(opwd_buf, service+5);
npwd=hmacpw(npwd_buf, service+5);
if (!opwd)
{
if (npwd)
free(npwd);
errno=EPERM;
return (1);
}
hmac_flag=1;
}
else
#endif
{
opwd=strdup(opwd_buf);
if (!opwd)
{
errno=EPERM;
return (1);
}
npwd=userdb_mkmd5pw(npwd_buf);
if (!npwd || !(npwd=strdup(npwd)))
{
free(opwd);
errno=EPERM;
return (1);
}
}
rc=dochangepwd1(service, uid, opwd, npwd, hmac_flag);
free(opwd);
free(npwd);
return (rc);
}
void test_result()
{
auto result01 = rr::result<bool, int>(0);
assert(!result01.ok());
assert(result01.bad());
assert(result01.ok() != result01.bad());
assert(result01.error() == 0);
assert(result01.take_or(true));
(void) result01;
rr::result<std::string, bool> result02 = false;
assert(result02.bad());
assert(!result02.ok());
assert(result02.ok() != result02.bad());
assert(result02.error() == false);
assert(result02.take_or("Hello, World!") == "Hello, World!");
(void) result02;
auto result03 = rr::result<unsigned int, int>(0U);
assert(result03.ok());
assert(result03.value() == 0);
assert(result03.take_or(42) == 0);
result03 = 0U;
result03.value() = 42;
assert(result03.value() == 42);
(void) result03;
auto result04 = rr::result<int, std::string>("Hello, World!");
assert(result04.bad());
assert(result04.error() == "Hello, World!");
(void) result04;
auto result05 = rr::result<std::string, int>("Hello, World!");
assert(result05.ok());
assert(result05.value() == "Hello, World!");
assert(result05.take() == "Hello, World!");
result05 = "Goodbye, World!";
assert(result05.ok());
assert(result05.value() == "Goodbye, World!");
result05 = EINVAL;
assert(!result05.ok());
assert(result05.bad());
assert(result05.error() == EINVAL);
(void) result05;
auto result06 = rr::result<std::vector<std::string>, int>(0);
result06 = std::vector<std::string>({ "A", "B", "C", "D" });
assert(result06.ok());
assert(!result06.bad());
assert(result06.value()[0] == "A");
assert(result06.value()[1] == "B");
assert(result06.value()[2] == "C");
assert(result06.value()[3] == "D");
assert(result06.value().size() == 4);
auto v1 = result06.take();
assert(v1[0] == "A");
assert(v1[1] == "B");
assert(v1[2] == "C");
assert(v1[3] == "D");
assert(v1.size() == 4);
result06 = EINVAL;
assert(result06.take_or(v1)[3] == "D");
assert(result06.take_or(std::move(v1))[3] == "D");
assert(result06.bad());
result06 = std::vector<std::string>({ "X", "Y", "Z" });
assert(result06.value()[0] == "X");
assert(result06.value()[1] == "Y");
assert(result06.value()[2] == "Z");
assert(result06.value().size() == 3);
assert(result06.ok());
auto result07 = std::move(result06);
assert(result07.ok());
(void) result06;
auto result08 = result07;
assert(result07.ok());
assert(result08.ok());
(void) result07;
rr::result<std::vector<std::string>, double> result09 = result08.take();
assert(result09.ok());
assert(result09.value()[0] == "X");
assert(result09.value()[1] == "Y");
assert(result09.value()[2] == "Z");
assert(result09.value().size() == 3);
(void) result09;
}
void run() {
good("A");
good("\xC2\xA2"); // cent: ¢
good("\xE2\x82\xAC"); // euro: €
good("\xF0\x9D\x90\x80"); // Blackboard A: 𝐀
//abrupt end
bad("\xC2");
bad("\xE2\x82");
bad("\xF0\x9D\x90");
bad("\xC2 ");
bad("\xE2\x82 ");
bad("\xF0\x9D\x90 ");
//too long
bad("\xF8\x80\x80\x80\x80");
bad("\xFC\x80\x80\x80\x80\x80");
bad("\xFE\x80\x80\x80\x80\x80\x80");
bad("\xFF\x80\x80\x80\x80\x80\x80\x80");
bad("\xF5\x80\x80\x80"); // U+140000 > U+10FFFF
bad("\x80"); //cant start with continuation byte
bad("\xC0\x80"); // 2-byte version of ASCII NUL
#undef good
#undef bad
}
void range(int value,int lo,int hi,const char *what) {
if (value<lo || value>=hi) {
CkPrintf("ERROR! %s: %d is out of range (%d,%d)!\n",what,value,lo,hi);
bad("Internal FEM data structure corruption! (out of range)\n");
}
}
void insert_line(ll m, ll b) {
auto y = insert({ m, b });
y->succ = [=] { return next(y) == end() ? 0 : &*next(y); };
if (bad(y)) { erase(y); return; }
while (next(y) != end() && bad(next(y))) erase(next(y));
while (y != begin() && bad(prev(y))) erase(prev(y)); }
// set the put pointer's position
ostream _FAR & ostream::seekp(streamoff off, ios::seek_dir dir)
{
if( bad() || bp->seekoff(off, dir, ios::out) == EOF )
setstate(ios::failbit);
return *this;
}
bool EncryptedStore::openRead(const QString& name)
{
Q_D(KOdfStore);
if (bad())
return false;
const KArchiveEntry* fileArchiveEntry = m_pZip->directory()->entry(name);
if (!fileArchiveEntry) {
return false;
}
if (fileArchiveEntry->isDirectory()) {
kWarning(30002) << name << " is a directory!";
return false;
}
const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(fileArchiveEntry);
delete d->stream;
d->stream = fileZipEntry->createDevice();
d->size = fileZipEntry->size();
if (m_encryptionData.contains(name)) {
// This file is encrypted, do some decryption first
if (m_bPasswordDeclined) {
// The user has already declined to give a password
// Open the file as empty
d->stream->close();
delete d->stream;
d->stream = new QBuffer();
d->stream->open(QIODevice::ReadOnly);
d->size = 0;
return true;
}
QCA::SecureArray encryptedFile(d->stream->readAll());
if (encryptedFile.size() != d->size) {
// Read error detected
d->stream->close();
delete d->stream;
d->stream = NULL;
kWarning(30002) << "read error";
return false;
}
d->stream->close();
delete d->stream;
d->stream = NULL;
KoEncryptedStore_EncryptionData encData = m_encryptionData.value(name);
QCA::SecureArray decrypted;
// If we don't have a password yet, try and find one
if (m_password.isEmpty()) {
findPasswordInKWallet();
}
while (true) {
QByteArray pass;
QCA::SecureArray password;
bool keepPass = false;
// I already have a password! Let's test it. If it's not good, we can dump it, anyway.
if (!m_password.isEmpty()) {
password = m_password;
m_password = QCA::SecureArray();
} else {
if (!m_filename.isNull())
keepPass = false;
QPointer<KPasswordDialog> dlg = new KPasswordDialog(d->window ,
keepPass ? KPasswordDialog::ShowKeepPassword : static_cast<KPasswordDialog::KPasswordDialogFlags>(0));
dlg->setPrompt(i18n("Please enter the password to open this file."));
if (! dlg->exec()) {
m_bPasswordDeclined = true;
d->stream = new QBuffer();
d->stream->open(QIODevice::ReadOnly);
d->size = 0;
delete dlg;
return true;
}
if (dlg) {
password = QCA::SecureArray(dlg->password().toUtf8());
if (keepPass)
keepPass = dlg->keepPassword();
if (password.isEmpty()) {
delete dlg;
continue;
}
}
delete dlg;
}
decrypted = decryptFile(encryptedFile, encData, password);
if (decrypted.isEmpty()) {
kError(30002) << "empty decrypted file" << endl;
return false;
}
if (!encData.checksum.isEmpty()) {
QCA::SecureArray checksum;
if (encData.checksumShort && decrypted.size() > 1024) {
// TODO: Eww!!!! I don't want to convert via insecure arrays to get the first 1K characters of a secure array <- fix QCA?
checksum = QCA::Hash("sha1").hash(QCA::SecureArray(decrypted.toByteArray().left(1024)));
} else {
checksum = QCA::Hash("sha1").hash(decrypted);
}
if (checksum != encData.checksum) {
continue;
}
}
// The password passed all possible tests, so let's accept it
m_password = password;
m_bPasswordUsed = true;
if (keepPass) {
savePasswordInKWallet();
}
break;
}
QByteArray *resultArray = new QByteArray(decrypted.toByteArray());
QIODevice *resultDevice = KFilterDev::device(new QBuffer(resultArray, NULL), "application/x-gzip");
if (!resultDevice) {
delete resultArray;
return false;
}
static_cast<KFilterDev*>(resultDevice)->setSkipHeaders();
d->stream = resultDevice;
d->size = encData.filesize;
}
d->stream->open(QIODevice::ReadOnly);
return true;
}
bool wxFBIPC::VerifySingleInstance( const wxString& file, bool switchTo )
{
// Possible send a message to the running instance through this string later, for now it is left empty
wxString expression = wxEmptyString;
// Make path absolute
wxFileName path( file );
if ( !path.IsOk() )
{
wxLogError( wxT("This path is invalid: %s"), file.c_str() );
return false;
}
if ( !path.IsAbsolute() )
{
if ( !path.MakeAbsolute() )
{
wxLogError( wxT("Could not make path absolute: %s"), file.c_str() );
return false;
}
}
// Check for single instance
// Create lockfile/mutex name
wxString name = wxString::Format( wxT("wxFormBuilder-%s-%s"), wxGetUserId().c_str(), path.GetFullPath().c_str() );
// Get forbidden characters
wxString forbidden = wxFileName::GetForbiddenChars();
// Repace forbidded characters
for ( size_t c = 0; c < forbidden.Length(); ++c )
{
wxString bad( forbidden.GetChar( c ) );
name.Replace( bad.c_str(), wxT("_") );
}
// Paths are not case sensitive in windows
#ifdef __WXMSW__
name = name.MakeLower();
#endif
// GetForbiddenChars is missing "/" in unix. Prepend '.' to make lockfiles hidden
#ifndef __WXMSW__
name.Replace( wxT("/"), wxT("_") );
name.Prepend( wxT(".") );
#endif
// Check to see if I already have a server with this name - if so, no need to make another!
if ( m_server.get() )
{
if ( m_server->m_name == name )
{
return true;
}
}
std::auto_ptr< wxSingleInstanceChecker > checker;
{
// Suspend logging, because error messages here are not useful
#ifndef __WXFB_DEBUG__
wxLogNull stopLogging;
#endif
checker.reset( new wxSingleInstanceChecker( name ) );
}
if ( !checker->IsAnotherRunning() )
{
// This is the first instance of this project, so setup a server and save the single instance checker
if ( CreateServer( name ) )
{
m_checker = checker;
return true;
}
else
{
return false;
}
}
else if ( switchTo )
{
// Suspend logging, because error messages here are not useful
#ifndef __WXFB_DEBUG__
wxLogNull stopLogging;
#endif
// There is another app, so connect and send the expression
// Cannot have a client and a server at the same time, due to the implementation of wxTCPServer and wxTCPClient,
// so temporarily drop the server if there is one
bool hadServer = false;
wxString oldName;
if ( m_server.get() != NULL )
{
oldName = m_server->m_name;
m_server.reset();
hadServer = true;
}
// Create the client
std::auto_ptr< AppClient > client( new AppClient );
// Create the connection
std::auto_ptr< wxConnectionBase > connection;
#ifdef __WXMSW__
connection.reset( client->MakeConnection( wxT("localhost"), name, name ) );
#else
bool connected = false;
for ( int i = m_port; i < m_port + 20; ++i )
{
#if wxVERSION_NUMBER < 2900
wxString nameWithPort = wxString::Format( wxT("%i%s"), i, name.c_str() );
connection.reset( client->MakeConnection( wxT("127.0.0.1"), nameWithPort, name ) );
#else
wxString sPort = wxString::Format( "%i", i );
connection.reset( client->MakeConnection( "localhost", sPort, name ) );
#endif
if ( NULL != connection.get() )
{
connected = true;
wxChar* pid = (wxChar*)connection->Request( wxT("PID"), NULL );
if ( NULL != pid )
{
wxLogStatus( wxT("%s already open in process %s"), file.c_str(), pid );
}
break;
}
}
if ( !connected )
{
wxLogError( wxT("There is a lockfile named '%s', but unable to make a connection to that instance."), name.c_str() );
}
#endif
// Drop the connection and client
connection.reset();
client.reset();
// Create the server again, if necessary
if ( hadServer )
{
CreateServer( oldName );
}
}
return false;
}
va_dcl
#else
(char *s, const char *fmt, ...)
#endif
{
char *s0;
va_list ap;
long L, *Lp;
int i, *ip, rc = 0;
#ifdef KR_headers
char *fmt, *s;
va_start(ap);
s = va_arg(ap, char*);
fmt = va_arg(ap, char*);
#else
va_start(ap, fmt);
#endif
for(;;) {
for(;;) {
switch(i = *(unsigned char *)fmt++) {
case 0:
goto done;
case '%':
break;
default:
if (i <= ' ') {
while(*s <= ' ')
if (!*s++)
return rc;
}
else if (*s++ != i)
return rc;
continue;
}
break;
}
switch(*fmt++) {
case 'l':
if (*fmt != 'd')
bad(fmt);
fmt++;
Lp = va_arg(ap, long*);
L = strtol(s0 = s, &s, 10);
if (s > s0) {
rc++;
*Lp = L;
continue;
}
return rc;
case 'd':
ip = va_arg(ap, int*);
L = strtol(s0 = s, &s, 10);
if (s > s0) {
rc++;
*ip = (int)L;
continue;
}
return rc;
default:
bad(fmt);
}
}
done:
return rc;
}
va_dcl
#else
(char *outbuf, const char *fmt, ...)
#endif
{
char *ob0, *s;
char buf[32];
va_list ap;
long i, j;
int rc = 0;
#ifdef KR_headers
char *outbuf, *fmt;
va_start(ap);
outbuf = va_arg(ap, char*);
fmt = va_arg(ap, char*);
#else
va_start(ap, fmt);
#endif
ob0 = outbuf;
for(;;) {
for(;;) {
switch(i = *fmt++) {
case 0:
goto done;
case '%':
break;
default:
put(i);
continue;
}
break;
}
switch(*fmt++) {
case 'c':
i = va_arg(ap, int);
put(i);
continue;
case 'l':
if (*fmt != 'd')
bad(fmt);
fmt++;
i = va_arg(ap, long);
goto have_i;
case 'd':
i = va_arg(ap, int);
have_i:
if (i < 0) {
put('-');
i = -i;
}
s = buf;
do {
j = i / 10;
*s++ = i - 10*j + '0';
}
while(i = j);
do {
i = *--s;
put(i);
}
while(s > buf);
continue;
case 's':
s = va_arg(ap, char*);
have_s:
while(i = *s++)
{ put(i); }
continue;
default:
bad(fmt);
}
}
done:
*outbuf = 0;
return outbuf - ob0;
}
int main(void) {
bad();
return 0;
}
void InitOffsets()
{
int j;
int argid;
INSTR_InstrCategory instrCat;
INSTR_OperandType* opType;
j=1;
argid=0;
instrCat = INSTR_instrType(call);
opType = INSTR_operandTypes(instrCat);
do{
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_I1:
callOffsets[CALL][ADDR][ARITY]=j++;
break;
case INSTR_L:
callOffsets[CALL][ADDR][LABEL]=j;
j+=sizeof(CodeInd);
break;
default:
bad("Internal Error: in code.c InitOffsets():A\n");
EM_THROW(LK_LinkError);
}
argid++;
}while(opType[argid]!=INSTR_X);
j=1;
argid=0;
instrCat = INSTR_instrType(execute);
opType = INSTR_operandTypes(instrCat);
do{
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_L:
callOffsets[EXECUTE][ADDR][LABEL]=j;
j+=sizeof(CodeInd);
break;
default:
bad("Internal Error: in code.c InitOffsets():B\n");
EM_THROW(LK_LinkError);
}
argid++;
}while(opType[argid]!=INSTR_X);
j=1;
argid=0;
instrCat = INSTR_instrType(call_name);
opType = INSTR_operandTypes(instrCat);
do{
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_I1:
callOffsets[CALL][NAME][ARITY]=j++;
break;
case INSTR_C:
callOffsets[CALL][NAME][LABEL]=j;
j+=sizeof(ConstInd);
break;
default:
bad("Internal Error: in code.c InitOffsets():C %x\n",opType[argid]);
EM_THROW(LK_LinkError);
}
argid++;
}while(opType[argid]!=INSTR_X);
j=1;
argid=0;
instrCat = INSTR_instrType(execute_name);
opType = INSTR_operandTypes(instrCat);
do{
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_C:
callOffsets[EXECUTE][NAME][LABEL]=j;
j+=sizeof(ConstInd);
break;
default:
bad("Internal Error: in code.c InitOffsets():D\n");
EM_THROW(LK_LinkError);
}
argid++;
}while(opType[argid]!=INSTR_X);
}
void WriteCode(int fd)
{
Word i,j;
Word size=LK_VECTOR_Size(&Code);
char* code=(char *)LK_VECTOR_GetPtr(&Code,0);
Byte opcode=-1;
INSTR_InstrCategory instrCat=INSTR_CAT_X;
INSTR_OperandType* opType=NULL;
int argid=0;
debug("Writing 0x%lx bytes of instructions at %lx.\n",size,lseek(fd,0,SEEK_CUR));
for(i=0;i<size;)
{
j=i;
opcode=code[j++];
instrCat=INSTR_instrType(opcode);
opType=INSTR_operandTypes(instrCat);
argid=-1;
LK_FILE_PUT1(fd,opcode);
debug("\t%lx:%lx:[%x]%s ",lseek(fd,0,SEEK_CUR)-1,i,opcode,INSTR_instrName(opcode));
do{
argid++;
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_SEG:
debug("SEG %d ",*(Byte*)(code+j));
case INSTR_R:
case INSTR_E:
case INSTR_N:
case INSTR_I1:
case INSTR_CE:
LK_FILE_PUT1(fd,*(Byte*)(code+j));
j+=sizeof(Byte);
break;
// case INSTR_I2:
// PUT2(*(TwoBytes*)(code+j));
// j+=sizeof(TwoBytes);
// break;
case INSTR_C:
PutConstInd(fd,UnPackConstInd(*(TwoBytes*)(code+j)));
j+=sizeof(TwoBytes);
break;
case INSTR_K:
PutKindInd(fd,UnPackKindInd(*(TwoBytes*)(code+j)));
j+=sizeof(TwoBytes);
break;
case INSTR_MT:
PutImportTabInd(fd,*(ImportTabInd*)(code+j));
j+=sizeof(ImportTabInd);
break;
case INSTR_IT:
PutImplGoalInd(fd,*(ImplGoalInd*)(code+j));
j+=sizeof(ImplGoalInd);
break;
case INSTR_HT:
PutHashTabInd(fd,*(HashTabInd*)(code+j));
j+=sizeof(HashTabInd);
break;
case INSTR_BVT:
PutBvrTabInd(fd,*(BvrTabInd*)(code+j));
j+=sizeof(BvrTabInd);
break;
case INSTR_S:
PutStringInd(fd,*(StringInd*)(code+j));
j+=sizeof(StringInd);
break;
case INSTR_L:
debug("L(%lx) ",*(CodeInd*)(code+j));
PutCodeInd(fd,*(CodeInd*)(code+j));
j+=sizeof(CodeInd);
break;
case INSTR_I:
LK_FILE_PUT4(fd,*(INT4*)(code+j));
j+=sizeof(INT4);
break;
case INSTR_F:
PutFloat(fd,*(INT4*)(code+j));
j+=sizeof(INT4);
break;
case INSTR_X:
break;
default:
bad("\nUnknown Operand Type %d\n",opType[argid]);
EM_THROW(LK_LinkError);
break; /* null instruction */
}
}
while(opType[argid]!=INSTR_X);
debug("\n");
i+=INSTR_instrSize(opcode);
}
}
void LoadCode(int fd, struct Module_st* CMData)
{
Word i,j;
Word offset=CMData->CodeOffset;
Word size=CMData->CodeSize;
Byte* code;
Byte opcode;
ConstInd tmpIndex;
INSTR_InstrCategory instrCat;
INSTR_OperandType* opType;
int argid=0;
if(size<=0){
debug("No code for current module.\n");
return;
}
debug("Loading 0x%lx bytes of code at %lx to offset 0x%lx.\n",size,lseek(fd,0,SEEK_CUR),offset);
code=(Byte*)LK_VECTOR_GetPtr(&Code,offset);
debug("After get\n");
opcode=-1;
instrCat=INSTR_CAT_X;
opType=NULL;
for(i=0;i<size;)
{
j=i;
opcode=code[j++]=LK_FILE_GET1(fd);
debug("\t%lx:%lx:[%x]%s\t",lseek(fd,0,SEEK_CUR)-1,i,opcode,INSTR_instrName(opcode));
if(opcode==call_link_only)
{
code[j]=LK_FILE_GET1(fd);
tmpIndex=GetConstInd(fd,CMData);
PushCall(CMData->Pit,tmpIndex,offset+i,code[j]);
i += INSTR_instrSize(opcode);
continue;
}
else if(opcode==execute_link_only)
{
tmpIndex=GetConstInd(fd,CMData);
PushCall(CMData->Pit,tmpIndex,offset+i,-1);
i += INSTR_instrSize(opcode);
continue;
}
instrCat=INSTR_instrType(opcode);
opType=INSTR_operandTypes(instrCat);
argid=0;
do{
switch(opType[argid])
{
case INSTR_P:
j++;
break;
case INSTR_WP:
j+=sizeof(Word);
break;
case INSTR_SEG:
LK_FILE_GET1(fd);//Consume dummy argument
*(Byte*)(code+j)=CMData->SegmentID;
debug("ID:%d\t",CMData->SegmentID);
j+=sizeof(Byte);
break;
case INSTR_R:
case INSTR_E:
case INSTR_N:
case INSTR_I1:
case INSTR_CE:
*(Byte*)(code+j)=LK_FILE_GET1(fd);
debug("%d\t",*(Byte*)(code+j));
j+=sizeof(Byte);
break;
// case INSTR_I2:
// *(TwoBytes*)(code+j)=GET2();
// j+=sizeof(TwoBytes);
// break;
case INSTR_C:
*(TwoBytes*)(code+j)=PackConstInd(GetConstInd(fd,CMData));
debug("C:%d\t",*(TwoBytes*)(code+j));
j+=sizeof(TwoBytes);
break;
case INSTR_K:
*(TwoBytes*)(code+j)=PackKindInd(GetKindInd(fd,CMData));
debug("K:%d\t",*(TwoBytes*)(code+j));
j+=sizeof(TwoBytes);
break;
case INSTR_MT:
*(ImportTabInd*)(code+j)=GetImportTabInd(fd,CMData);
debug("IT:%d\t",*(ImportTabInd*)(code+j));
j+=sizeof(ImportTabInd);
break;
case INSTR_IT:
*(ImplGoalInd*)(code+j)=GetImplGoalInd(fd,CMData);
debug("IG:%d\t",*(ImplGoalInd*)(code+j));
j+=sizeof(ImplGoalInd);
break;
case INSTR_HT:
*(HashTabInd*)(code+j)=GetHashTabInd(fd,CMData);
debug("HT:%d\t",*(HashTabInd*)(code+j));
j+=sizeof(HashTabInd);
break;
case INSTR_BVT:
*(BvrTabInd*)(code+j)=GetBvrTabInd(fd,CMData);
debug("BT:%d\t",*(BvrTabInd*)(code+j));
j+=sizeof(BvrTabInd);
break;
case INSTR_S:
*(StringInd*)(code+j)=GetStringInd(fd,CMData);
debug("S:%d\t",*(StringInd*)(code+j));
j+=sizeof(StringInd);
break;
case INSTR_L:
*(CodeInd*)(code+j)=GetCodeInd(fd,CMData);
debug("L:%d\t",*(CodeInd*)(code+j));
j+=sizeof(CodeInd);
break;
case INSTR_I:
*(INT4*)(code+j)=LK_FILE_GET4(fd);
debug("I:%d\t",*(INT4*)(code+j));
j+=sizeof(INT4);
break;
case INSTR_F:
*(INT4*)(code+j)=GetFloat(fd);
debug("F:%d\t",*(INT4*)(code+j));
j+=sizeof(INT4);
break;
case INSTR_X:
break;
default:
bad("Unknown Operand Type %d\n",opType[argid]);
EM_THROW(LK_LinkError);
break;
}
argid++;
}
while(opType[argid]!=INSTR_X);
debug("\n");
i += INSTR_instrSize(opcode);
}
debug("NOWD -> %d[%d,%d]\n",166,(*(ConstInd*)(code+166)).gl_flag,(*(ConstInd*)(code+166)).index);
}
void ini_control_transfer(usb_dev_handle *dev) {
int r,i;
char question[] = { 0x01,0x01 };
r = usb_control_msg(dev, 0x21, 0x09, 0x0201, 0x00, (char *) question, 2, timeout);
if( r < 0 )
{
perror("USB control write"); bad("USB write failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",question[i] & 0xFF);
printf("\n");
}
}