int TLKFile::finalWriteHeader(void)
{
char *magic;
if(seek(0)) return errcode;
if(!(magic = (char*) getFileMagicByResType(type))) return errcode = 11;
if(rawWrite(magic, 4)) return errcode;
if(rawWrite("V3.0", 4)) return errcode;
if(binWrite(3, (uint32) language, strcount, offstrings)) return errcode;
return errcode = 0;
}
int SSFFile::finalWriteHeader(void)
{
char *magic;
if(seek(0)) return errcode;
if(!(magic = (char*) getFileMagicByResType(type))) return errcode = 11;
if(rawWrite(magic, 4)) return errcode;
if(rawWrite("V1.0", 4)) return errcode;
if(binWrite(2, entrycount, offtable)) return errcode;
return errcode = 0;
}
int ERFFile::finalWriteHeader(void)
{
char *magic;
if(seek(0)) return errcode;
if(!(magic = (char*) getFileMagicByResType(type))) return errcode = 11;
if(rawWrite(magic, 4)) return errcode;
if(rawWrite("V1.0", 4)) return errcode;
if(binWrite(9, langcount, locstrsize, entrycount, offlocstr, offkeylist,
offreslist, buildyear, buildday, desc.stringref))
return errcode;
return errcode = 0;
}
int GFFFile::finalWriteHeader(void)
{
char *magic;
if(seek(0)) return errcode;
if(!(magic = (char*) getFileMagicByResType(type))) return errcode = 11;
if(rawWrite(magic, 4)) return errcode;
if(rawWrite("V3.2", 4)) return errcode;
if(binWrite(12, offstruct, structcount, offfield, fieldcount, offlabel,
labelcount, offfielddata, fielddatasize, offfieldidx,
fieldidxsize, offlistidx, listidxsize))
return errcode;
return errcode = 0;
}
void OutputPersistenceBlock::write(bool value) {
writeMarker(BOOL_MARKER);
uint uintBool = value ? 1 : 0;
uintBool = TO_LE_32(uintBool);
rawWrite(&uintBool, sizeof(uintBool));
}
int TLKFile::finalWriteStrings(void)
{
if(seek(offstrings)) return errcode;
for(uint32 i=0;i<strcount;i++)
if(rawWrite(strings[i])) return errcode;
return errcode = 0;
}
int ERFFile::writeData(std::string resref, NWNFileType restype, uint8 *memseg,
uint32 size, bool copy)
{
uint32 n;
if(pronto)
{
if(prontowritten++ >= entrycount) return errcode = 31;
if(offsets.empty()) return errcode = 25;
if(offsets.size() < 2) offsets.push_back(offsets[0]);
if(seek(offsets[1])) return errcode;
if(rawWrite((char *) memseg, size)) return errcode;
offsets[1] += size;
}
else
{
datas.resize((n=datas.size())+1);
if(copy)
{
if(!(datas[n] = (uint8 *) malloc(size))) return errcode = 4;
memcpy(datas[n], memseg, size);
}
else datas[n] = memseg;
datac.push_back(copy);
}
resrefs.push_back(resref);
restypes.push_back(restype);
sizes.push_back(size);
return errcode = 0;
}
void OutputPersistenceBlock::write(bool value) {
writeMarker(BOOL_MARKER);
uint uintBool = value ? 1 : 0;
uintBool = convertEndianessFromSystemToStorage(uintBool);
rawWrite(&uintBool, sizeof(uintBool));
}
/* ----------------------------------------------------------------------
* LOW LEVEL DEVICE IO ROUTINES - PORT TO QIODEVICE REQUIRED BEFORE COMMIT
*
*
* HIGH LEVEL IO
* int sendCommand() - writes a command to the device
* int readMessage() - reads an inbound message
*
* LOW LEVEL IO
* openPort() - opens serial device and configures it
* closePort() - closes serial device and releases resources
* rawRead() - non-blocking read of inbound data
* rawWrite() - non-blocking write of outbound data
* discover() - check if a ct is attached to the port specified
* ---------------------------------------------------------------------- */
int Fortius::sendCommand(int mode) // writes a command to the device
{
switch (mode) {
case FT_ERGOMODE :
return rawWrite(ERGO_Command, 12);
break;
case FT_SSMODE :
return rawWrite(SLOPE_Command, 12);
break;
default :
return -1;
break;
}
}
size_t writeString( const ptr_t address,
const std::basic_string<char_t>& value) const
{
if(!value.length())
return 0;
const size_t stringLength = (value.length() + 1) * sizeof(char_t);
return rawWrite(address, &value[0], stringLength);
}
void OutputPersistenceBlock::write(float value) {
writeMarker(FLOAT_MARKER);
uint32 tmp[1];
((float *)tmp)[0] = value;
tmp[0] = TO_LE_32(tmp[0]);
rawWrite(&value, sizeof(value));
}
int ERFFile::finalWriteEntries(void)
{
if(pronto) return errcode = 29;
if(offsets.empty()) return errcode = 25;
if(seek(offsets[0])) return errcode;
for(uint32 i=0;i<entrycount;i++)
if(rawWrite((char *) datas[i], sizes[i])) return errcode;
return errcode = 0;
}
int GFFFile::finalWriteResRef(std::string &resref, uint32 &ofieldd)
{
if(binWrite((uint32) (ofieldd-offfielddata))) return errcode;
if(seek(ofieldd)) return errcode;
if(binWrite((uint8) resref.size())) return errcode;
if(rawWrite((char*) resref.c_str(), resref.size())) return errcode;
// Overflow check, if that fires, something really bad happened
if((ofieldd += resref.size()+1) > offfieldidx) return errcode = 23;
return errcode = 0;
}
int GFFFile::finalWriteExoStr(std::string &exostr, uint32 &ofieldd)
{
if(binWrite((uint32) (ofieldd-offfielddata))) return errcode;
if(seek(ofieldd)) return errcode;
if(binWrite((uint32) exostr.size())) return errcode;
if(rawWrite((char*) exostr.c_str(), exostr.size())) return errcode;
// Overflow check, if that fires, something really bad happened
if((ofieldd += exostr.size()+4) > offfieldidx) return errcode = 23;
return errcode = 0;
}
int GFFFile::finalWriteLabels(void)
{
int l;
if(seek(offlabel)) return errcode;
for(uint32 i=0;i<labels.size();i++)
{
if(rawWrite(labels[i].c_str(), l=labels[i].length()))
return errcode;
// Pad to a total of 16 bytes
for(l=l;l<16;l++) if(binWrite((uint8) 0)) return errcode;
}
return errcode = 0;
}
int ERFFile::finalWriteDescription(void)
{
if(seek(offlocstr)) return errcode;
for(uint32 i=0;i<NWN_LANG_MAX;i++)
if(!desc.str[i].empty())
{
if(binWrite(2, i, (uint32) desc.str[i].length())) return errcode;
if(rawWrite((char*) desc.str[i].c_str(), desc.str[i].size()))
return errcode;
}
// Overflow check, if that fires, something really bad happened
if(tell() > offkeylist) return errcode = 23;
return errcode = 0;
}
static int formattedWrite( int fd , const char* format, ... ) {
const int MAX_ENTRY = 256;
static char entryBuf[MAX_ENTRY];
va_list ap;
va_start( ap , format );
int entrySize = vsnprintf( entryBuf , MAX_ENTRY-1 , format , ap );
if ( entrySize < 0 ) {
return -1;
}
if ( rawWrite( fd , entryBuf , entrySize ) < 0 ) {
return -1;
}
return 0;
}
int SSFFile::finalWriteData(void)
{
uint32 l;
if(offsets.empty()) return errcode = 25;
if(seek(offsets[0])) return errcode;
for(uint32 i=0;i<entrycount;i++)
{
// ResRefs have to have at most 16 characters
if(resrefs[i].length() > 16) resrefs[i].erase(16);
if(rawWrite((char*) resrefs[i].c_str(), l=resrefs[i].length()))
return errcode;
// Pad to a total of 16 bytes
for(l=l;l<16;l++) if(binWrite((uint8) 0)) return errcode;
if(binWrite(stringrefs[i])) return errcode;
}
return errcode = 0;
}
int GFFFile::finalWriteExoLocStr(ExoLocString &exolocstr, uint32 &ofieldd)
{
uint32 size=0, count=0;
if(binWrite((uint32) (ofieldd-offfielddata))) return errcode;
if(seek(ofieldd+12)) return errcode;
for(uint32 i=0;i<NWN_LANG_MAX;i++)
if(!exolocstr.str[i].empty())
{
if(binWrite(2, i, (uint32) exolocstr.str[i].size()))
return errcode;
if(rawWrite((char*) exolocstr.str[i].c_str(), exolocstr.str[i].size()))
return errcode;
count++;
size += exolocstr.str[i].size()+8;
}
if(seek(ofieldd)) return errcode;
if(binWrite(3, (uint32) size+8, exolocstr.stringref, count)) return errcode;
// Overflow check, if that fires, something really bad happened
if((ofieldd += size+12) > offfieldidx) return errcode = 23;
return errcode = 0;
}
int ERFFile::finalWriteKeyList(void)
{
int l;
if(seek(offkeylist)) return errcode;
for(uint32 i=0;i<entrycount;i++)
{
// ResRefs have to have at most 16 characters
if(resrefs[i].length() > 16) resrefs[i].erase(16);
lowerStr(resrefs[i]);
if(rawWrite((char*) resrefs[i].c_str(), l=resrefs[i].length()))
return errcode;
// Pad to a total of 16 bytes
for(l=l;l<16;l++) if(binWrite((uint8) 0)) return errcode;
if(binWrite(i)) return errcode;
if(binWrite((uint16) restypes[i])) return errcode;
if(binWrite((uint16) 0)) return errcode;
// Overflow check, if that fires, something really bad happened
if(tell() > offreslist) return errcode = 23;
}
return errcode = 0;
}
int ERFFile::writeData(std::string resref, NWNFileType restype, std::string fname)
{
uint32 n, size;
if(pronto && (prontowritten++ >= entrycount)) return errcode = 31;
datas.resize((n=datas.size())+1);
if(!(datas[n] = readFileIntoMem(fname, size))) return errcode;
if(pronto)
{
if(offsets.empty()) return errcode = 25;
if(offsets.size() < 2) offsets.push_back(offsets[0]);
if(seek(offsets[1])) return errcode;
if(rawWrite((char *) datas[n], size)) return errcode;
offsets[1] += size;
free(datas[n]);
datas.resize(n);
}
else datac.push_back(true);
resrefs.push_back(resref);
restypes.push_back(restype);
sizes.push_back(size);
return errcode = 0;
}
int TLKFile::finalWriteTable(void)
{
uint32 l;
if(seek(20)) return errcode;
offsets.resize(1);
offsets[0] = 0;
for(uint32 i=0;i<strcount;i++)
{
if(binWrite((uint32) flags[i])) return errcode;
// ResRefs have to have at most 16 characters
if(sndresrefs[i].length() > 16) sndresrefs[i].erase(16);
if(rawWrite((char*) sndresrefs[i].c_str(), l=sndresrefs[i].length()))
return errcode;
// Pad to a total of 16 bytes
for(l=l;l<16;l++) if(binWrite((uint8) 0)) return errcode;
if(binWrite(2, (uint32) 0, (uint32) 0)) return errcode;
if(binWrite(2, offsets[0], (uint32) strings[i].length())) return errcode;
if(binWrite(sndlengths[i])) return errcode;
offsets[0] += strings[i].length();
}
return errcode = 0;
}
bool OwRelay::set(uint8_t i, bool value) {
if (rlyState[i] == value) return true;
bool ok = rawWrite(os->getAddr(i), value);
if (ok) rlyState[i] = value;
return ok;
}
/*
* NAME: dasd_write
*
* FUNCTION: Write to direct access file descriptor
*
* PARAMETERS:
* offset - Starting byte offset for write request
* pdata - Starting address of user data buffer
* plen - On entry, number of bytes to be write
* On exit, number of bytes actually write
* vfsp - pointer to vfs structure
*
* RETURNS: 0 for success; Other indicates failure
*/
int32
dasd_write(
int64 offset,
caddr_t pdata,
int64 *plen,
struct vfs *vfsp)
{
int64 blocknum;
cbuf_t *bp;
dio_t *dp;
inode_t *dummy_inode;
int64 erroff;
int64 fbytes;
int64 lbytes;
int64 mbytes;
int64 nbytes = *plen;
int32 rc;
dummy_inode = getDummyInode(vfsp);
/* If offset does not start on sector boundary, calculate number of
* bytes in first partial sector.
*/
if (offset & (vfsp->vfs_bsize - 1))
{
fbytes = MIN(nbytes, CM_BSIZE - (offset & CM_OFFSET));
nbytes -= fbytes;
}
else
fbytes = 0;
/* If write does not end on sector boundary, calculate number of
* bytes in last sector
*/
if (nbytes & vfsp->vfs_bsize - 1)
lbytes = nbytes & CM_OFFSET;
else
lbytes = 0;
mbytes = nbytes - lbytes;
nbytes = 0; /* Now counting bytes actually written */
/* First (partial) block */
if (fbytes)
{
if (rc = rawRead(dummy_inode, offset, &bp))
goto out1;
if (rc = copyin(pdata, bp->cm_cdata+(offset & CM_OFFSET),
fbytes))
{
rawRelease(bp);
goto out1;
}
if (rc = rawWrite(dummy_inode, bp, 1))
goto out1;
nbytes = fbytes;
offset += fbytes;
pdata += fbytes;
}
/* Write full sectors
*/
if (mbytes)
{
blocknum = offset >> dummy_inode->i_l2pbsize;
if (rc = dioStart(dummy_inode, &dp))
goto out1;
(void) dioWrite(dp, blocknum, mbytes, offset, pdata, 0);
if (rc = dioEnd(dp, &erroff))
{
nbytes += (erroff - offset);
goto out1;
}
nbytes += mbytes;
offset += mbytes;
pdata += mbytes;
}
/* Write last (partial) block
*/
if (lbytes)
{
if (rc = rawRead(dummy_inode, offset, &bp))
goto out1;
if (rc = copyin(pdata, bp->cm_cdata, lbytes))
{
rawRelease(bp);
goto out1;
}
if (rc = rawWrite(dummy_inode, bp, 1))
goto out1;
nbytes = +lbytes;
}
out1:
releDummyInode(dummy_inode);
*plen = nbytes;
return (rc);
}
int main() {
const char* test = "hello there\n";
rawWrite(test, strlen(test));
return 0;
}
int writeDIODir(latero_conn* latero, uint16_t value ) {
return( rawWrite( latero, LATERO_IO, 0x18, value ) );
}
void OutputPersistenceBlock::write(uint value) {
writeMarker(UINT_MARKER);
value = TO_LE_32(value);
rawWrite(&value, sizeof(value));
}
void OutputPersistenceBlock::writeString(const Common::String &string) {
writeMarker(STRING_MARKER);
write(string.size());
rawWrite(string.c_str(), string.size());
}
void OutputPersistenceBlock::writeByteArray(Common::Array<byte> &value) {
writeMarker(BLOCK_MARKER);
write((uint)value.size());
rawWrite(&value[0], value.size());
}
int my_main(const char* str_latero_ip, int print_response, int npack,
unsigned int* dacval, int dacval_cnt,
char rd, char wr, int addr, int value, char dst_main, char dst_io, int testpattern )
{
latero_conn latero;
/*
struct sockaddr_in si_server, si_other;
int s, ii, slen=sizeof(si_other);
char pktbuff[BUFLEN];
char rspbuff[BUFLEN];
*/
int ii;
uint8_t blades[64];
uint16_t dio_out = 0x0000;
// For raw address commands
uint16_t saddr = 0x0000;
uint16_t sdata = 0x0000;
latero_dst_device destination;
int numbytes = 0;
latero_pkt_t response;
printf("Init Connection: ");
if ( ii = init_connection( &latero, str_latero_ip ) < 0 ) {
printf("Error (%d)!\n",ii );
return(-1);
} else {
printf("OK.\n");
}
// Sanitize the dac values
for(ii = 0 ; ii < 4 ; ii++ ) {
if (ii < dacval_cnt ) {
setDAC( &latero, ii, dacval[ii] );
}
}
/*
for(ii = 0 ; ii<64 ; ii++ ) {
blades[ii] = ii;
}
setBlades( &latero, blades );
*/
// Run a few test cases here
TestInit();
ii = 0;
switch(testpattern) {
case 1:
TestSplit1(&latero);
sleep(1);
TestSplit2(&latero);
break;
case 2:
TestAllpin(&latero);
break;
case 3:
TestRow(&latero);
sleep(1);
TestCol(&latero);
break;
case 4:
// Test continuously without stopping
while(1) {
printf("%d ", ii);
TestRow(&latero);
printf("%d ", ii);
TestCol(&latero);
ii++;
}
break;
}
/* Just on led is turned on... */
setDIO( &latero, 0xDEAC );
// setDAC( &latero, 0x0, 0x1234 );
// setDAC( &latero, 0x1, 0x5678 );
// setDAC( &latero, 0x2, 0x9ABC );
// setDAC( &latero, 0x3, 0xDEF0 );
printf("Sending\n");
sendNormalPacket( &latero, &response );
printf("printing\n");
printPacket( &response );
/*
printf("Test Connection\n");
if( test_connection( &latero ) < 0 ) {
fprintf(stderr,"The test_connection() failed\n");
} else {
printf("Connection with Latero is OK.\n");
}
*/
if( rd > 0 || wr > 0 ) {
saddr = addr & 0xFFFF;
sdata = value & 0xFFFF;
if ( dst_main > 0 ) {
destination = LATERO_CONTROLLER;
} else if ( dst_io > 0 ) {
destination = LATERO_IO;
}
if( rd > 0 ) {
rawRead( &latero, destination, saddr, &sdata );
printf("Data Read at address 0x%4.4X = 0x%4.4X\n", saddr,sdata);
} else { /* Write */
rawWrite(&latero, destination, saddr, sdata );
printf("0x%4.4X written at address 0x%4.4X\n", sdata,saddr );
}
} else {
// Normal Latero Packets
//fillNormalPacket(PKT_TYPE_FULL, dac, blades, dio_out, &packetSend);
}
return( close_connection( &latero ) );
}
