Compare commits
39 Commits
stream_2_5
...
stream_2_6
| Author | SHA1 | Date | |
|---|---|---|---|
| cc9adc77fa | |||
| 2b38f7bcfa | |||
| 0ceada70b5 | |||
| 7bf91b403d | |||
| bf5c359649 | |||
| c41ac44bd1 | |||
| e36013d64e | |||
| 9e48ad3e61 | |||
| 054e74d04a | |||
| 5f6319ed3d | |||
| 2f39622a57 | |||
| 7801119215 | |||
| a6696cae49 | |||
| 40b52167aa | |||
| 814e3d53a3 | |||
| 6bd46e0470 | |||
| d5cda13f6f | |||
| bfc8e6a9cd | |||
| 73cba130c3 | |||
| c09bc44aa4 | |||
| b907e3f469 | |||
| 8c3bed09e4 | |||
| 4c99b82bb7 | |||
| a6d72761b9 | |||
| 6c504d30cf | |||
| 1c814a451b | |||
| daafc125c3 | |||
| 63f680bdc1 | |||
| e88a327957 | |||
| 223c71bc68 | |||
| 14a04fd200 | |||
| dc85511fe9 | |||
| d0b8d3f585 | |||
| 97652917c9 | |||
| c171a62f93 | |||
| c7c28e7fa2 | |||
| 79a17788f2 | |||
| 9f0a2d2fb6 | |||
| 66f6ce9bd2 |
@ -88,11 +88,11 @@ many process variables distributed over many records.
|
||||
|
||||
<h2>Recommended Readings</h2>
|
||||
<p>
|
||||
<a href="http://www.aps.anl.gov/epics/base/R3-14/8-docs/AppDevGuide.pdf"
|
||||
target="ex">IOC Application Developer's Guide (PDF)</a>
|
||||
<a href="http://www.aps.anl.gov/epics/base/R3-14/12-docs/AppDevGuide"
|
||||
target="ex">IOC Application Developer's Guide</a>
|
||||
</p>
|
||||
<p>
|
||||
<a href="http://www.aps.anl.gov/asd/controls/epics/EpicsDocumentation/AppDevManuals/RecordRef/Recordref-1.html"
|
||||
<a href="https://wiki-ext.aps.anl.gov/epics/index.php/RRM_3-14"
|
||||
target="ex">EPICS Record Reference Manual</a>
|
||||
</p>
|
||||
|
||||
|
||||
@ -261,7 +261,7 @@ number in the range of <code>-128</code> to <code>255</code>,
|
||||
or <code>-0200</code> to <code>0377</code>, respectively.
|
||||
</p>
|
||||
<p>
|
||||
<em>StreamDevice</em> also recordgnizes the ASCII symbolic names
|
||||
<em>StreamDevice</em> also recognizes the ASCII symbolic names
|
||||
(not case sensitive) for several byte codes:<br>
|
||||
<code>NUL </code>(= <code>0x00</code>) <em>null</em><br>
|
||||
<code>SOH </code>(= <code>0x01</code>) <em>start of heading</em><br>
|
||||
|
||||
@ -22,11 +22,6 @@
|
||||
#include "StreamError.h"
|
||||
#include "StreamBuffer.h"
|
||||
|
||||
#include <epicsVersion.h>
|
||||
#ifdef BASE_VERSION
|
||||
#define EPICS_3_13
|
||||
#endif
|
||||
|
||||
#ifdef EPICS_3_13
|
||||
#include <assert.h>
|
||||
#include <wdLib.h>
|
||||
@ -203,7 +198,7 @@ class AsynDriverInterface : StreamBusInterface
|
||||
|
||||
// local methods
|
||||
void timerExpired();
|
||||
bool connectToBus(const char* busname, int addr);
|
||||
bool connectToBus(const char* portname, int addr);
|
||||
void lockHandler();
|
||||
void writeHandler();
|
||||
void readHandler();
|
||||
@ -247,7 +242,7 @@ class AsynDriverInterface : StreamBusInterface
|
||||
public:
|
||||
// static creator method
|
||||
static StreamBusInterface* getBusInterface(Client* client,
|
||||
const char* busname, int addr, const char* param);
|
||||
const char* portname, int addr, const char* param);
|
||||
};
|
||||
|
||||
RegisterStreamBusInterface(AsynDriverInterface);
|
||||
@ -255,6 +250,7 @@ RegisterStreamBusInterface(AsynDriverInterface);
|
||||
AsynDriverInterface::
|
||||
AsynDriverInterface(Client* client) : StreamBusInterface(client)
|
||||
{
|
||||
debug ("AsynDriverInterface(%s)\n", client->name());
|
||||
pasynCommon = NULL;
|
||||
pasynOctet = NULL;
|
||||
intrPvtOctet = NULL;
|
||||
@ -266,20 +262,25 @@ AsynDriverInterface(Client* client) : StreamBusInterface(client)
|
||||
eventMask = 0;
|
||||
receivedEvent = 0;
|
||||
peeksize = 1;
|
||||
debug ("AsynDriverInterface(%s) createAsynUser\n", client->name());
|
||||
pasynUser = pasynManager->createAsynUser(handleRequest,
|
||||
handleTimeout);
|
||||
assert(pasynUser);
|
||||
pasynUser->userPvt = this;
|
||||
#ifdef EPICS_3_13
|
||||
debug ("AsynDriverInterface(%s) wdCreate()\n", client->name());
|
||||
timer = wdCreate();
|
||||
callbackSetCallback(expire, &timeoutCallback);
|
||||
callbackSetUser(this, &timeoutCallback);
|
||||
#else
|
||||
debug ("AsynDriverInterface(%s) epicsTimerQueueActive::allocate(true)\n", client->name());
|
||||
timerQueue = &epicsTimerQueueActive::allocate(true);
|
||||
assert(timerQueue);
|
||||
debug ("AsynDriverInterface(%s) timerQueue->createTimer()\n", client->name());
|
||||
timer = &timerQueue->createTimer();
|
||||
assert(timer);
|
||||
#endif
|
||||
debug ("AsynDriverInterface(%s) done\n", client->name());
|
||||
}
|
||||
|
||||
AsynDriverInterface::
|
||||
@ -325,17 +326,19 @@ AsynDriverInterface::
|
||||
}
|
||||
|
||||
// interface function getBusInterface():
|
||||
// do we have this bus/addr ?
|
||||
// do we have this port/addr ?
|
||||
StreamBusInterface* AsynDriverInterface::
|
||||
getBusInterface(Client* client,
|
||||
const char* busname, int addr, const char*)
|
||||
const char* portname, int addr, const char*)
|
||||
{
|
||||
debug ("AsynDriverInterface::getBusInterface(%s, %s, %d)\n",
|
||||
client->name(), portname, addr);
|
||||
AsynDriverInterface* interface = new AsynDriverInterface(client);
|
||||
if (interface->connectToBus(busname, addr))
|
||||
if (interface->connectToBus(portname, addr))
|
||||
{
|
||||
debug ("AsynDriverInterface::getBusInterface(%s, %d): "
|
||||
"new Interface allocated\n",
|
||||
busname, addr);
|
||||
"new interface allocated\n",
|
||||
portname, addr);
|
||||
return interface;
|
||||
}
|
||||
delete interface;
|
||||
@ -347,7 +350,62 @@ getBusInterface(Client* client,
|
||||
bool AsynDriverInterface::
|
||||
supportsEvent()
|
||||
{
|
||||
return (pasynInt32 != NULL) || (pasynUInt32 != NULL);
|
||||
if (intrPvtInt32 || intrPvtUInt32) return true;
|
||||
|
||||
// look for interfaces for events
|
||||
asynInterface* pasynInterface;
|
||||
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynInt32Type, true);
|
||||
if (pasynInterface)
|
||||
{
|
||||
pasynInt32 = static_cast<asynInt32*>(pasynInterface->pinterface);
|
||||
pvtInt32 = pasynInterface->drvPvt;
|
||||
pasynUser->reason = ASYN_REASON_SIGNAL; // required for GPIB
|
||||
if (pasynInt32->registerInterruptUser(pvtInt32, pasynUser,
|
||||
intrCallbackInt32, this, &intrPvtInt32) == asynSuccess)
|
||||
{
|
||||
printf ("%s: AsynDriverInterface::supportsEvent: "
|
||||
"pasynInt32->registerInterruptUser(%p, %p, %p, %p, %p)\n",
|
||||
clientName(), pvtInt32, pasynUser,
|
||||
intrCallbackInt32, this, &intrPvtInt32);
|
||||
return true;
|
||||
}
|
||||
error("%s: port does not allow to register for "
|
||||
"Int32 interrupts: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
pasynInt32 = NULL;
|
||||
intrPvtInt32 = NULL;
|
||||
}
|
||||
|
||||
// no asynInt32 available, thus try asynUInt32
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynUInt32DigitalType, true);
|
||||
if (pasynInterface)
|
||||
{
|
||||
pasynUInt32 =
|
||||
static_cast<asynUInt32Digital*>(pasynInterface->pinterface);
|
||||
pvtUInt32 = pasynInterface->drvPvt;
|
||||
pasynUser->reason = ASYN_REASON_SIGNAL;
|
||||
if (pasynUInt32->registerInterruptUser(pvtUInt32,
|
||||
pasynUser, intrCallbackUInt32, this, 0xFFFFFFFF,
|
||||
&intrPvtUInt32) == asynSuccess)
|
||||
{
|
||||
printf ("%s: AsynDriverInterface::supportsEvent: "
|
||||
"pasynUInt32->registerInterruptUser(%p, %p, %p, %p, %#X, %p)\n",
|
||||
clientName(), pvtUInt32, pasynUser,
|
||||
intrCallbackUInt32, this, 0xFFFFFFFF, &intrPvtInt32);
|
||||
return true;
|
||||
}
|
||||
error("%s: port does not allow to register for "
|
||||
"UInt32 interrupts: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
pasynUInt32 = NULL;
|
||||
intrPvtUInt32 = NULL;
|
||||
}
|
||||
|
||||
// no event interface available
|
||||
return false;
|
||||
}
|
||||
|
||||
bool AsynDriverInterface::
|
||||
@ -359,20 +417,26 @@ supportsAsyncRead()
|
||||
if (pasynOctet->registerInterruptUser(pvtOctet, pasynUser,
|
||||
intrCallbackOctet, this, &intrPvtOctet) != asynSuccess)
|
||||
{
|
||||
error("%s: bus does not support asynchronous input: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
const char *portname;
|
||||
pasynManager->getPortName(pasynUser, &portname);
|
||||
error("%s: asyn port %s does not support asynchronous input: %s\n",
|
||||
clientName(), portname, pasynUser->errorMessage);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool AsynDriverInterface::
|
||||
connectToBus(const char* busname, int addr)
|
||||
connectToBus(const char* portname, int addr)
|
||||
{
|
||||
if (pasynManager->connectDevice(pasynUser, busname, addr) !=
|
||||
asynSuccess)
|
||||
asynStatus status = pasynManager->connectDevice(pasynUser, portname, addr);
|
||||
debug("%s: AsynDriverInterface::connectToBus(%s, %d): "
|
||||
"pasynManager->connectDevice(%p, %s, %d) = %s\n",
|
||||
clientName(), portname, addr, pasynUser,portname, addr,
|
||||
asynStatusStr[status]);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
// asynDriver does not know this busname/address
|
||||
// asynDriver does not know this portname/address
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -381,10 +445,10 @@ connectToBus(const char* busname, int addr)
|
||||
// find the asynCommon interface
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynCommonType, true);
|
||||
if(!pasynInterface)
|
||||
if (!pasynInterface)
|
||||
{
|
||||
error("%s: bus %s does not support asynCommon interface\n",
|
||||
clientName(), busname);
|
||||
error("%s: asyn port %s does not support asynCommon interface\n",
|
||||
clientName(), portname);
|
||||
return false;
|
||||
}
|
||||
pasynCommon = static_cast<asynCommon*>(pasynInterface->pinterface);
|
||||
@ -393,10 +457,10 @@ connectToBus(const char* busname, int addr)
|
||||
// find the asynOctet interface
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynOctetType, true);
|
||||
if(!pasynInterface)
|
||||
if (!pasynInterface)
|
||||
{
|
||||
error("%s: bus %s does not support asynOctet interface\n",
|
||||
clientName(), busname);
|
||||
error("%s: asyn port %s does not support asynOctet interface\n",
|
||||
clientName(), portname);
|
||||
return false;
|
||||
}
|
||||
pasynOctet = static_cast<asynOctet*>(pasynInterface->pinterface);
|
||||
@ -405,7 +469,7 @@ connectToBus(const char* busname, int addr)
|
||||
// is it a GPIB interface ?
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynGpibType, true);
|
||||
if(pasynInterface)
|
||||
if (pasynInterface)
|
||||
{
|
||||
pasynGpib = static_cast<asynGpib*>(pasynInterface->pinterface);
|
||||
pvtGpib = pasynInterface->drvPvt;
|
||||
@ -413,50 +477,6 @@ connectToBus(const char* busname, int addr)
|
||||
// (read only one byte first).
|
||||
peeksize = inputBuffer.capacity();
|
||||
}
|
||||
|
||||
// look for interfaces for events
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynInt32Type, true);
|
||||
if(pasynInterface)
|
||||
{
|
||||
pasynInt32 = static_cast<asynInt32*>(pasynInterface->pinterface);
|
||||
pvtInt32 = pasynInterface->drvPvt;
|
||||
pasynUser->reason = ASYN_REASON_SIGNAL; // required for GPIB
|
||||
if (pasynInt32->registerInterruptUser(pvtInt32, pasynUser,
|
||||
intrCallbackInt32, this, &intrPvtInt32) == asynSuccess)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
error("%s: bus %s does not allow to register for "
|
||||
"Int32 interrupts: %s\n",
|
||||
clientName(), busname, pasynUser->errorMessage);
|
||||
pasynInt32 = NULL;
|
||||
intrPvtInt32 = NULL;
|
||||
}
|
||||
|
||||
// no asynInt32 available, thus try asynUInt32
|
||||
pasynInterface = pasynManager->findInterface(pasynUser,
|
||||
asynUInt32DigitalType, true);
|
||||
if(pasynInterface)
|
||||
{
|
||||
pasynUInt32 =
|
||||
static_cast<asynUInt32Digital*>(pasynInterface->pinterface);
|
||||
pvtUInt32 = pasynInterface->drvPvt;
|
||||
pasynUser->reason = ASYN_REASON_SIGNAL;
|
||||
if (pasynUInt32->registerInterruptUser(pvtUInt32,
|
||||
pasynUser, intrCallbackUInt32, this, 0xFFFFFFFF,
|
||||
&intrPvtUInt32) == asynSuccess)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
error("%s: bus %s does not allow to register for "
|
||||
"UInt32 interrupts: %s\n",
|
||||
clientName(), busname, pasynUser->errorMessage);
|
||||
pasynUInt32 = NULL;
|
||||
intrPvtUInt32 = NULL;
|
||||
}
|
||||
|
||||
// no event interface available, never mind
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -475,13 +495,20 @@ lockRequest(unsigned long lockTimeout_ms)
|
||||
status = pasynManager->isConnected(pasynUser, &connected);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s: pasynManager->isConnected() failed: %s\n",
|
||||
error("%s lockRequest: pasynManager->isConnected() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
return false;
|
||||
}
|
||||
if (!connected)
|
||||
{
|
||||
const char *portname;
|
||||
pasynManager->getPortName(pasynUser, &portname);
|
||||
error("%s lockRequest: asyn port %s is not connected\n",
|
||||
clientName(), portname);
|
||||
return false;
|
||||
}
|
||||
status = pasynManager->queueRequest(pasynUser,
|
||||
connected ? priority() : asynQueuePriorityConnect,
|
||||
lockTimeout);
|
||||
priority(), lockTimeout);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s lockRequest: pasynManager->queueRequest() failed: %s\n",
|
||||
@ -503,9 +530,13 @@ connectToAsynPort()
|
||||
debug("AsynDriverInterface::connectToAsynPort(%s)\n",
|
||||
clientName());
|
||||
status = pasynManager->isConnected(pasynUser, &connected);
|
||||
debug("%s: AsynDriverInterface::connectToAsynPort: "
|
||||
"pasynManager->isConnected(%p, %p) = %s => %s\n",
|
||||
clientName(), pasynUser, &connected, asynStatusStr[status],
|
||||
connected ? "yes" : "no");
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s: pasynManager->isConnected() failed: %s\n",
|
||||
error("%s connectToAsynPort: pasynManager->isConnected() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
return false;
|
||||
}
|
||||
@ -537,13 +568,19 @@ connectToAsynPort()
|
||||
clientName(), connected ? "already" : "not yet");
|
||||
if (!connected)
|
||||
{
|
||||
printf ("%s: AsynDriverInterface::connectToAsynPort: "
|
||||
"pasynCommon->connect(%p, %p)\n",
|
||||
clientName(), pvtCommon, pasynUser);
|
||||
status = pasynCommon->connect(pvtCommon, pasynUser);
|
||||
printf ("%s: AsynDriverInterface::connectToAsynPort: "
|
||||
"pasynCommon->connect(%p, %p) = %s\n",
|
||||
clientName(), pvtCommon, pasynUser, asynStatusStr[status]);
|
||||
debug("AsynDriverInterface::connectToAsynPort(%s): "
|
||||
"status=%s\n",
|
||||
clientName(), asynStatusStr[status]);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s: pasynCommon->connect() failed: %s\n",
|
||||
error("%s connectToAsynPort: pasynCommon->connect() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
return false;
|
||||
}
|
||||
@ -561,21 +598,55 @@ connectToAsynPort()
|
||||
void AsynDriverInterface::
|
||||
lockHandler()
|
||||
{
|
||||
asynStatus status;
|
||||
int connected;
|
||||
|
||||
debug("AsynDriverInterface::lockHandler(%s)\n",
|
||||
clientName());
|
||||
pasynManager->blockProcessCallback(pasynUser, false);
|
||||
connected = connectToAsynPort();
|
||||
lockCallback(connected ? StreamIoSuccess : StreamIoFault);
|
||||
|
||||
status = pasynManager->isConnected(pasynUser, &connected);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s lockHandler: pasynManager->isConnected() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
lockCallback(StreamIoFault);
|
||||
return;
|
||||
}
|
||||
if (!connected)
|
||||
{
|
||||
const char *portname;
|
||||
pasynManager->getPortName(pasynUser, &portname);
|
||||
error("%s lockHandler: asyn port %s is not connected\n",
|
||||
clientName(), portname);
|
||||
lockCallback(StreamIoFault);
|
||||
}
|
||||
|
||||
status = pasynManager->blockProcessCallback(pasynUser, false);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s lockHandler: pasynManager->blockProcessCallback() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
lockCallback(StreamIoFault);
|
||||
return;
|
||||
}
|
||||
lockCallback(StreamIoSuccess);
|
||||
}
|
||||
|
||||
// interface function: we don't need exclusive access any more
|
||||
bool AsynDriverInterface::
|
||||
unlock()
|
||||
{
|
||||
asynStatus status;
|
||||
|
||||
debug("AsynDriverInterface::unlock(%s)\n",
|
||||
clientName());
|
||||
pasynManager->unblockProcessCallback(pasynUser, false);
|
||||
status = pasynManager->unblockProcessCallback(pasynUser, false);
|
||||
if (status != asynSuccess)
|
||||
{
|
||||
error("%s unlock: pasynManager->unblockProcessCallback() failed: %s\n",
|
||||
clientName(), pasynUser->errorMessage);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -618,20 +689,24 @@ writeHandler()
|
||||
asynStatus status;
|
||||
size_t written = 0;
|
||||
|
||||
pasynUser->timeout = 0;
|
||||
if (pasynGpib)
|
||||
pasynOctet->flush(pvtOctet, pasynUser);
|
||||
else
|
||||
// discard any early input, but forward it to potential async records
|
||||
// thus do not use pasynOctet->flush()
|
||||
pasynUser->timeout = 0;
|
||||
do {
|
||||
char buffer [256];
|
||||
size_t received = sizeof(buffer);
|
||||
size_t received = 0;
|
||||
int eomReason = 0;
|
||||
status = pasynOctet->read(pvtOctet, pasynUser,
|
||||
buffer, received, &received, &eomReason);
|
||||
buffer, sizeof(buffer), &received, &eomReason);
|
||||
if (received == 0) break;
|
||||
#ifndef NO_TEMPORARY
|
||||
if (received) debug("AsynDriverInterface::writeHandler(%s): flushing %ld bytes: \"%s\"\n",
|
||||
clientName(), (long)received, StreamBuffer(buffer, received).expand()());
|
||||
#endif
|
||||
} while (status != asynTimeout);
|
||||
} while (status == asynSuccess);
|
||||
|
||||
// discard any early events
|
||||
receivedEvent = 0;
|
||||
@ -673,7 +748,7 @@ writeHandler()
|
||||
"device is %sconnected\n",
|
||||
clientName(),connected?"":"dis");
|
||||
if (!connected) {
|
||||
error("%s: connection closed in write\n",
|
||||
error("%s: write failed because connection was closed by device\n",
|
||||
clientName());
|
||||
writeCallback(StreamIoFault);
|
||||
return;
|
||||
@ -1216,7 +1291,7 @@ acceptEvent(unsigned long mask, unsigned long replytimeout_ms)
|
||||
}
|
||||
eventMask = mask;
|
||||
ioAction = ReceiveEvent;
|
||||
startTimer(replytimeout_ms*0.001);
|
||||
if (replytimeout_ms) startTimer(replytimeout_ms*0.001);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -27,12 +27,9 @@
|
||||
#endif
|
||||
#include <ctype.h>
|
||||
|
||||
typedef unsigned long ulong;
|
||||
typedef unsigned char uchar;
|
||||
typedef unsigned int (*checksumFunc)(const unsigned char* data, unsigned int len, unsigned int init);
|
||||
|
||||
typedef ulong (*checksumFunc)(const uchar* data, ulong len, ulong init);
|
||||
|
||||
static ulong sum(const uchar* data, ulong len, ulong sum)
|
||||
static unsigned int sum(const unsigned char* data, unsigned int len, unsigned int sum)
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
@ -41,7 +38,7 @@ static ulong sum(const uchar* data, ulong len, ulong sum)
|
||||
return sum;
|
||||
}
|
||||
|
||||
static ulong xor8(const uchar* data, ulong len, ulong sum)
|
||||
static unsigned int xor8(const unsigned char* data, unsigned int len, unsigned int sum)
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
@ -50,15 +47,15 @@ static ulong xor8(const uchar* data, ulong len, ulong sum)
|
||||
return sum;
|
||||
}
|
||||
|
||||
static ulong xor7(const uchar* data, ulong len, ulong sum)
|
||||
static unsigned int xor7(const unsigned char* data, unsigned int len, unsigned int sum)
|
||||
{
|
||||
return xor8(data, len, sum) & 0x7F;
|
||||
}
|
||||
|
||||
static ulong crc_0x07(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x07(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^8 + x^2 + x^1 + x^0 (0x07)
|
||||
const static uchar table[256] = {
|
||||
const static unsigned char table[256] = {
|
||||
0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
|
||||
0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
|
||||
0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
|
||||
@ -96,10 +93,10 @@ static ulong crc_0x07(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x31(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x31(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^8 + x^5 + x^4 + x^0 (0x31)
|
||||
const static uchar table[256] = {
|
||||
const static unsigned char table[256] = {
|
||||
0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83,
|
||||
0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
|
||||
0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e,
|
||||
@ -137,7 +134,7 @@ static ulong crc_0x31(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x8005(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x8005(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^16 + x^15 + x^2 + x^0 (0x8005)
|
||||
const static unsigned short table[256] = {
|
||||
@ -178,7 +175,7 @@ static ulong crc_0x8005(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x8005_r(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x8005_r(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^16 + x^15 + x^2 + x^0 (0x8005)
|
||||
// reflected
|
||||
@ -220,7 +217,7 @@ static ulong crc_0x8005_r(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x1021(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x1021(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^16 + x^12 + x^5 + x^0 (0x1021)
|
||||
const static unsigned short table[256] = {
|
||||
@ -261,7 +258,7 @@ static ulong crc_0x1021(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x04C11DB7(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x04C11DB7(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 +
|
||||
// x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + x^0 (0x04C11DB7)
|
||||
@ -335,7 +332,7 @@ static ulong crc_0x04C11DB7(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong crc_0x04C11DB7_r(const uchar* data, ulong len, ulong crc)
|
||||
static unsigned int crc_0x04C11DB7_r(const unsigned char* data, unsigned int len, unsigned int crc)
|
||||
{
|
||||
// x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 +
|
||||
// x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + x^0 (0x04C11DB7)
|
||||
@ -410,13 +407,13 @@ static ulong crc_0x04C11DB7_r(const uchar* data, ulong len, ulong crc)
|
||||
return crc;
|
||||
}
|
||||
|
||||
static ulong adler32(const uchar* data, ulong len, ulong init)
|
||||
static unsigned int adler32(const unsigned char* data, unsigned int len, unsigned int init)
|
||||
{
|
||||
ulong a = init & 0xFFFF;
|
||||
ulong b = (init >> 16) & 0xFFFF;
|
||||
unsigned int a = init & 0xFFFF;
|
||||
unsigned int b = (init >> 16) & 0xFFFF;
|
||||
|
||||
while (len) {
|
||||
ulong tlen = len > 5550 ? 5550 : len;
|
||||
unsigned int tlen = len > 5550 ? 5550 : len;
|
||||
len -= tlen;
|
||||
do {
|
||||
a += *data++;
|
||||
@ -431,10 +428,10 @@ static ulong adler32(const uchar* data, ulong len, ulong init)
|
||||
return b << 16 | a;
|
||||
}
|
||||
|
||||
static ulong hexsum(const uchar* data, ulong len, ulong sum)
|
||||
static unsigned int hexsum(const unsigned char* data, unsigned int len, unsigned int sum)
|
||||
{
|
||||
// Add all hex digits, ignore all other bytes.
|
||||
ulong d;
|
||||
unsigned int d;
|
||||
while (len--)
|
||||
{
|
||||
d = toupper(*data++);
|
||||
@ -452,8 +449,8 @@ struct checksum
|
||||
{
|
||||
const char* name;
|
||||
checksumFunc func;
|
||||
ulong init;
|
||||
ulong xorout;
|
||||
unsigned int init;
|
||||
unsigned int xorout;
|
||||
signed char bytes;
|
||||
};
|
||||
|
||||
@ -465,20 +462,6 @@ static checksum checksumMap[] =
|
||||
{"sum8", sum, 0x00, 0x00, 1}, // 0xDD
|
||||
{"sum16", sum, 0x0000, 0x0000, 2}, // 0x01DD
|
||||
{"sum32", sum, 0x00000000, 0x00000000, 4}, // 0x000001DD
|
||||
{"nsum", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"negsum", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"-sum", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"nsum8", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"negsum8", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"-sum8", sum, 0xFF, 0xFF, 1}, // 0x23
|
||||
{"nsum16", sum, 0xFFFF, 0xFFFF, 2}, // 0xFE23
|
||||
{"negsum16",sum, 0xFFFF, 0xFFFF, 2}, // 0xFE23
|
||||
{"-sum16", sum, 0xFFFF, 0xFFFF, 2}, // 0xFE23
|
||||
{"nsum32", sum, 0xFFFFFFFF, 0xFFFFFFFF, 4}, // 0xFFFFFE23
|
||||
{"negsum32",sum, 0xFFFFFFFF, 0xFFFFFFFF, 4}, // 0xFFFFFE23
|
||||
{"-sum32", sum, 0xFFFFFFFF, 0xFFFFFFFF, 4}, // 0xFFFFFE23
|
||||
{"notsum", sum, 0x00, 0xFF, 1}, // 0x22
|
||||
{"~sum", sum, 0x00, 0xFF, 1}, // 0x22
|
||||
{"xor", xor8, 0x00, 0x00, 1}, // 0x31
|
||||
{"xor8", xor8, 0x00, 0x00, 1}, // 0x31
|
||||
{"xor7", xor7, 0x00, 0x00, 1}, // 0x31
|
||||
@ -498,7 +481,7 @@ static checksum checksumMap[] =
|
||||
{"hexsum8", hexsum, 0x00, 0x00, 1} // 0x2D
|
||||
};
|
||||
|
||||
static ulong mask[5] = {0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF};
|
||||
static unsigned int mask[5] = {0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF};
|
||||
|
||||
class ChecksumConverter : public StreamFormatConverter
|
||||
{
|
||||
@ -517,39 +500,80 @@ parse(const StreamFormat&, StreamBuffer& info, const char*& source, bool)
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t fnum;
|
||||
bool negflag=false;
|
||||
bool notflag=false;
|
||||
if (*source == '-')
|
||||
{
|
||||
source++;
|
||||
negflag = true;
|
||||
}
|
||||
if (strncasecmp(source, "neg", 3) == 0)
|
||||
{
|
||||
source+=3;
|
||||
negflag = true;
|
||||
}
|
||||
if (*source == '~')
|
||||
{
|
||||
source++;
|
||||
notflag = true;
|
||||
}
|
||||
if (strncasecmp(source, "not", 3) == 0)
|
||||
{
|
||||
source+=3;
|
||||
notflag = true;
|
||||
}
|
||||
unsigned fnum;
|
||||
int len = p-source;
|
||||
unsigned int init, xorout;
|
||||
for (fnum = 0; fnum < sizeof(checksumMap)/sizeof(checksum); fnum++)
|
||||
{
|
||||
if (strncasecmp(source, checksumMap[fnum].name, p-source) == 0)
|
||||
if ((strncasecmp(source, checksumMap[fnum].name, len) == 0) ||
|
||||
(*source == 'n' && len > 1 && strncasecmp(source+1, checksumMap[fnum].name, len-1) == 0 && (negflag = true)))
|
||||
{
|
||||
init = checksumMap[fnum].init;
|
||||
xorout = checksumMap[fnum].xorout;
|
||||
if (negflag)
|
||||
{
|
||||
init = ~init;
|
||||
xorout = ~xorout;
|
||||
}
|
||||
if (notflag)
|
||||
{
|
||||
xorout = ~xorout;
|
||||
}
|
||||
info.append(&init, sizeof(init));
|
||||
info.append(&xorout, sizeof(xorout));
|
||||
info.append(fnum);
|
||||
source = p+1;
|
||||
return pseudo_format;
|
||||
}
|
||||
}
|
||||
|
||||
error ("Unknown checksum algorithm \"%.*s\"\n",
|
||||
static_cast<int>(p-source), source);
|
||||
error ("Unknown checksum algorithm \"%.*s\"\n", len, source);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ChecksumConverter::
|
||||
printPseudo(const StreamFormat& format, StreamBuffer& output)
|
||||
{
|
||||
ulong sum;
|
||||
int fnum = format.info[0];
|
||||
unsigned int sum;
|
||||
const char* info = format.info;
|
||||
unsigned int init = extract<unsigned int>(info);
|
||||
unsigned int xorout = extract<unsigned int>(info);
|
||||
int fnum = extract<char>(info);
|
||||
|
||||
int start = format.width;
|
||||
int length = output.length()-format.width;
|
||||
if (format.prec > 0) length -= format.prec;
|
||||
|
||||
debug("ChecksumConverter %s: output to check: \"%s\"\n",
|
||||
checksumMap[fnum].name, output.expand(start,length)());
|
||||
|
||||
sum = (xorout ^ checksumMap[fnum].func(
|
||||
reinterpret_cast<unsigned char*>(output(start)), length, init))
|
||||
& mask[checksumMap[fnum].bytes];
|
||||
|
||||
sum = (checksumMap[fnum].xorout ^ checksumMap[fnum].func(
|
||||
reinterpret_cast<uchar*>(output(start)), length,
|
||||
checksumMap[fnum].init)) & mask[checksumMap[fnum].bytes];
|
||||
|
||||
debug("ChecksumConverter %s: output checksum is 0x%lX\n",
|
||||
debug("ChecksumConverter %s: output checksum is 0x%X\n",
|
||||
checksumMap[fnum].name, sum);
|
||||
|
||||
int i;
|
||||
@ -559,13 +583,11 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
|
||||
{
|
||||
// get number of decimal digits from number of bytes: ceil(xbytes*2.5)
|
||||
i = (checksumMap[fnum].bytes+1)*25/10-2;
|
||||
output.print("%0*ld", i, sum);
|
||||
debug("ChecksumConverter %s: decimal appending %0*ld\n",
|
||||
output.print("%0*d", i, sum);
|
||||
debug("ChecksumConverter %s: decimal appending %0*d\n",
|
||||
checksumMap[fnum].name, i, sum);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
if (format.flags & alt_flag) // lsb first (little endian)
|
||||
{
|
||||
for (i = 0; i < checksumMap[fnum].bytes; i++)
|
||||
@ -575,6 +597,10 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
|
||||
checksumMap[fnum].name, outchar);
|
||||
if (format.flags & zero_flag) // ASCII
|
||||
output.print("%02X", outchar);
|
||||
else
|
||||
if (format.flags & left_flag) // poor man's hex: 0x30 - 0x3F
|
||||
output.print("%c%c",
|
||||
((outchar>>4)&0x0f)|0x30, (outchar&0x0f)|0x30);
|
||||
else // binary
|
||||
output.append(outchar);
|
||||
sum >>= 8;
|
||||
@ -590,6 +616,10 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
|
||||
checksumMap[fnum].name, outchar);
|
||||
if (format.flags & zero_flag) // ASCII
|
||||
output.print("%02X", outchar);
|
||||
else
|
||||
if (format.flags & left_flag) // poor man's hex: 0x30 - 0x3F
|
||||
output.print("%c%c",
|
||||
((outchar>>4)&0x0f)|0x30, (outchar&0x0f)|0x30);
|
||||
else // binary
|
||||
output.append(outchar);
|
||||
sum <<= 8;
|
||||
@ -601,57 +631,88 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
|
||||
int ChecksumConverter::
|
||||
scanPseudo(const StreamFormat& format, StreamBuffer& input, long& cursor)
|
||||
{
|
||||
int fnum = format.info[0];
|
||||
ulong sum;
|
||||
unsigned int sum;
|
||||
const char* info = format.info;
|
||||
unsigned int init = extract<unsigned int>(info);
|
||||
unsigned int xorout = extract<unsigned int>(info);
|
||||
int start = format.width;
|
||||
int fnum = extract<char>(info);
|
||||
int length = cursor-format.width;
|
||||
|
||||
if (format.prec > 0) length -= format.prec;
|
||||
|
||||
debug("ChecksumConverter %s: input to check: \"%s\n",
|
||||
checksumMap[fnum].name, input.expand(start,length)());
|
||||
|
||||
if (input.length() - cursor <
|
||||
(format.flags & zero_flag ? 2 : 1) * checksumMap[fnum].bytes)
|
||||
int expectedLength =
|
||||
// get number of decimal digits from number of bytes: ceil(bytes*2.5)
|
||||
format.flags & sign_flag ? (checksumMap[fnum].bytes + 1) * 25 / 10 - 2 :
|
||||
format.flags & (zero_flag|left_flag) ? 2 * checksumMap[fnum].bytes :
|
||||
checksumMap[fnum].bytes;
|
||||
|
||||
if (input.length() - cursor < expectedLength)
|
||||
{
|
||||
error("Input too short for checksum\n");
|
||||
debug("ChecksumConverter %s: Input '%s' too short for checksum\n",
|
||||
checksumMap[fnum].name, input.expand(cursor)());
|
||||
return -1;
|
||||
}
|
||||
|
||||
sum = (checksumMap[fnum].xorout ^ checksumMap[fnum].func(
|
||||
reinterpret_cast<uchar*>(input(start)), length,
|
||||
checksumMap[fnum].init)) & mask[checksumMap[fnum].bytes];
|
||||
sum = (xorout ^ checksumMap[fnum].func(
|
||||
reinterpret_cast<unsigned char*>(input(start)), length, init))
|
||||
& mask[checksumMap[fnum].bytes];
|
||||
|
||||
debug("ChecksumConverter %s: input checksum is 0x%0*lX\n",
|
||||
debug("ChecksumConverter %s: input checksum is 0x%0*X\n",
|
||||
checksumMap[fnum].name, 2*checksumMap[fnum].bytes, sum);
|
||||
|
||||
int i,j;
|
||||
int i, j;
|
||||
unsigned inchar;
|
||||
|
||||
if (format.flags & sign_flag) // decimal
|
||||
{
|
||||
ulong sumin = 0;
|
||||
// get number of decimal digits from number of bytes: ceil(xbytes*2.5)
|
||||
j = (checksumMap[fnum].bytes+1)*25/10-2;
|
||||
for (i = 0; i < j; i++)
|
||||
unsigned int sumin = 0;
|
||||
for (i = 0; i < expectedLength; i++)
|
||||
{
|
||||
inchar = input[cursor+i];
|
||||
if (isdigit(inchar)) sumin = sumin*10+inchar-'0';
|
||||
else break;
|
||||
}
|
||||
if (sumin==sum) return i;
|
||||
error("Input %0*lu does not match checksum %0*lu\n",
|
||||
i, sumin, j, sum);
|
||||
return -1;
|
||||
if (sumin != sum)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input %0*u does not match checksum %0*u\n",
|
||||
checksumMap[fnum].name, i, sumin, expectedLength, sum);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
else
|
||||
if (format.flags & alt_flag) // lsb first (little endian)
|
||||
{
|
||||
for (i = 0; i < checksumMap[fnum].bytes; i++)
|
||||
{
|
||||
if (format.flags & zero_flag) // ASCII
|
||||
{
|
||||
sscanf(input(cursor+2*i), "%2X", &inchar);
|
||||
if (sscanf(input(cursor+2*i), "%2X", &inchar) != 1)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input byte '%s' is not a hex byte\n",
|
||||
checksumMap[fnum].name, input.expand(cursor+2*i,2)());
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
if (format.flags & left_flag) // poor man's hex: 0x30 - 0x3F
|
||||
{
|
||||
if ((input[cursor+2*i] & 0xf0) != 0x30)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X is not in range 0x30 - 0x3F\n",
|
||||
checksumMap[fnum].name, input[cursor+2*i]);
|
||||
return -1;
|
||||
}
|
||||
if ((input[cursor+2*i+1] & 0xf0) != 0x30)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X is not in range 0x30 - 0x3F\n",
|
||||
checksumMap[fnum].name, input[cursor+2*i+1]);
|
||||
return -1;
|
||||
}
|
||||
inchar = ((input[cursor+2*i] & 0x0f) << 4) | (input[cursor+2*i+1] & 0x0f);
|
||||
}
|
||||
else // binary
|
||||
{
|
||||
@ -659,8 +720,8 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, long& cursor)
|
||||
}
|
||||
if (inchar != ((sum >> 8*i) & 0xff))
|
||||
{
|
||||
error("Input byte 0x%02X does not match checksum 0x%0*lX\n",
|
||||
inchar, 2*checksumMap[fnum].bytes, sum);
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X does not match checksum 0x%0*X\n",
|
||||
checksumMap[fnum].name, inchar, 2*checksumMap[fnum].bytes, sum);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@ -673,21 +734,36 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, long& cursor)
|
||||
{
|
||||
sscanf(input(cursor+2*i), "%2x", &inchar);
|
||||
}
|
||||
else
|
||||
if (format.flags & left_flag) // poor man's hex: 0x30 - 0x3F
|
||||
{
|
||||
if ((input[cursor+2*i] & 0xf0) != 0x30)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X is not in range 0x30 - 0x3F\n",
|
||||
checksumMap[fnum].name, input[cursor+2*i]);
|
||||
return -1;
|
||||
}
|
||||
if ((input[cursor+2*i+1] & 0xf0) != 0x30)
|
||||
{
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X is not in range 0x30 - 0x3F\n",
|
||||
checksumMap[fnum].name, input[cursor+2*i+1]);
|
||||
return -1;
|
||||
}
|
||||
inchar = ((input[cursor+2*i] & 0x0f) << 4) | (input[cursor+2*i+1] & 0x0f);
|
||||
}
|
||||
else // binary
|
||||
{
|
||||
inchar = input[cursor+i] & 0xff;
|
||||
}
|
||||
if (inchar != ((sum >> 8*j) & 0xff))
|
||||
{
|
||||
error("Input byte 0x%02X does not match checksum 0x%0*lX\n",
|
||||
inchar, 2*checksumMap[fnum].bytes, sum);
|
||||
debug("ChecksumConverter %s: Input byte 0x%02X does not match checksum 0x%0*X\n",
|
||||
checksumMap[fnum].name, inchar, 2*checksumMap[fnum].bytes, sum);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (format.flags & zero_flag) // ASCII
|
||||
return 2*checksumMap[fnum].bytes;
|
||||
return checksumMap[fnum].bytes;
|
||||
return expectedLength;
|
||||
}
|
||||
|
||||
RegisterConverter (ChecksumConverter, "<");
|
||||
|
||||
@ -30,15 +30,17 @@
|
||||
#define vsnprintf epicsVsnprintf
|
||||
#endif
|
||||
|
||||
#define P PRINTF_SIZE_T_PREFIX
|
||||
|
||||
void StreamBuffer::
|
||||
init(const void* s, long minsize)
|
||||
init(const void* s, ssize_t minsize)
|
||||
{
|
||||
len = 0;
|
||||
offs = 0;
|
||||
buffer = local;
|
||||
cap = sizeof(local);
|
||||
if (minsize < 0) minsize = 0;
|
||||
if (minsize >= cap)
|
||||
if ((size_t)minsize >= cap)
|
||||
{
|
||||
// use allocated buffer
|
||||
grow(minsize);
|
||||
@ -55,18 +57,18 @@ init(const void* s, long minsize)
|
||||
}
|
||||
|
||||
// How the buffer looks like:
|
||||
// |----free-----|####used####|-------free-------|
|
||||
// |----free-----|####used####|--------00--------|
|
||||
///|<--- offs -->|<-- len --->|<- cap-offs-len ->|
|
||||
// 0 offs offs+len cap
|
||||
// |<-------------- minsize --------------->
|
||||
|
||||
|
||||
void StreamBuffer::
|
||||
grow(long minsize)
|
||||
grow(size_t minsize)
|
||||
{
|
||||
// make space for minsize + 1 (for termination) bytes
|
||||
char* newbuffer;
|
||||
long newcap;
|
||||
size_t newcap;
|
||||
#ifdef EXPLODE
|
||||
if (minsize > 1000000)
|
||||
{
|
||||
@ -117,12 +119,12 @@ grow(long minsize)
|
||||
}
|
||||
|
||||
StreamBuffer& StreamBuffer::
|
||||
append(const void* s, long size)
|
||||
append(const void* s, ssize_t size)
|
||||
{
|
||||
if (size <= 0)
|
||||
{
|
||||
// append negative number of bytes? let's delete some
|
||||
if (size < -len) size = -len;
|
||||
if (size < -(ssize_t)len) size = -(ssize_t)len;
|
||||
memset (buffer+offs+len+size, 0, -size);
|
||||
}
|
||||
else
|
||||
@ -134,8 +136,8 @@ append(const void* s, long size)
|
||||
return *this;
|
||||
}
|
||||
|
||||
long int StreamBuffer::
|
||||
find(const void* m, long size, long start) const
|
||||
ssize_t StreamBuffer::
|
||||
find(const void* m, size_t size, ssize_t start) const
|
||||
{
|
||||
if (start < 0)
|
||||
{
|
||||
@ -147,7 +149,7 @@ find(const void* m, long size, long start) const
|
||||
const char* s = static_cast<const char*>(m);
|
||||
char* b = buffer+offs;
|
||||
char* p = b+start;
|
||||
long i;
|
||||
size_t i;
|
||||
while ((p = static_cast<char*>(memchr(p, s[0], b-p+len-size+1))))
|
||||
{
|
||||
for (i = 1; i < size; i++)
|
||||
@ -161,7 +163,7 @@ next: p++;
|
||||
}
|
||||
|
||||
StreamBuffer& StreamBuffer::
|
||||
replace(long remstart, long remlen, const void* ins, long inslen)
|
||||
replace(ssize_t remstart, ssize_t remlen, const void* ins, ssize_t inslen)
|
||||
{
|
||||
if (remstart < 0)
|
||||
{
|
||||
@ -187,12 +189,12 @@ replace(long remstart, long remlen, const void* ins, long inslen)
|
||||
remlen += remstart;
|
||||
remstart = 0;
|
||||
}
|
||||
if (remstart > len)
|
||||
if ((size_t)remstart > len)
|
||||
{
|
||||
// remove begins after bufferend
|
||||
remstart = len;
|
||||
}
|
||||
if (remlen >= len-remstart)
|
||||
if ((size_t)remlen >= len-remstart)
|
||||
{
|
||||
// truncate remove after bufferend
|
||||
remlen = len-remstart;
|
||||
@ -205,12 +207,12 @@ replace(long remstart, long remlen, const void* ins, long inslen)
|
||||
return *this;
|
||||
}
|
||||
if (inslen < 0) inslen = 0;
|
||||
long remend = remstart+remlen;
|
||||
long newlen = len+inslen-remlen;
|
||||
size_t remend = remstart+remlen;
|
||||
size_t newlen = len+inslen-remlen;
|
||||
if (cap <= newlen)
|
||||
{
|
||||
// buffer too short
|
||||
long newcap;
|
||||
size_t newcap;
|
||||
for (newcap = sizeof(local)*2; newcap <= newlen; newcap *= 2);
|
||||
char* newbuffer = new char[newcap];
|
||||
memcpy(newbuffer, buffer+offs, remstart);
|
||||
@ -251,13 +253,13 @@ StreamBuffer& StreamBuffer::
|
||||
print(const char* fmt, ...)
|
||||
{
|
||||
va_list va;
|
||||
int printed;
|
||||
ssize_t printed;
|
||||
while (1)
|
||||
{
|
||||
va_start(va, fmt);
|
||||
printed = vsnprintf(buffer+offs+len, cap-offs-len, fmt, va);
|
||||
va_end(va);
|
||||
if (printed > -1 && printed < (int)(cap-offs-len))
|
||||
if (printed > -1 && printed < (ssize_t)(cap-offs-len))
|
||||
{
|
||||
len += printed;
|
||||
return *this;
|
||||
@ -267,9 +269,9 @@ print(const char* fmt, ...)
|
||||
}
|
||||
}
|
||||
|
||||
StreamBuffer StreamBuffer::expand(long start, long length) const
|
||||
StreamBuffer StreamBuffer::expand(ssize_t start, ssize_t length) const
|
||||
{
|
||||
long end;
|
||||
size_t end;
|
||||
if (start < 0)
|
||||
{
|
||||
start += len;
|
||||
@ -289,7 +291,7 @@ StreamBuffer StreamBuffer::expand(long start, long length) const
|
||||
StreamBuffer result((end-start)*2);
|
||||
start += offs;
|
||||
end += offs;
|
||||
long i;
|
||||
size_t i;
|
||||
char c;
|
||||
for (i = start; i < end; i++)
|
||||
{
|
||||
@ -311,8 +313,8 @@ dump() const
|
||||
{
|
||||
StreamBuffer result(256+cap*5);
|
||||
result.append("\033[0m");
|
||||
long i;
|
||||
result.print("%ld,%ld,%ld:\033[37m", offs, len, cap);
|
||||
size_t i;
|
||||
result.print("%"P"d,%"P"d,%"P"d:\033[37m", offs, len, cap);
|
||||
for (i = 0; i < cap; i++)
|
||||
{
|
||||
if (i == offs) result.append("\033[34m[\033[0m");
|
||||
|
||||
@ -21,29 +21,34 @@
|
||||
#define StreamBuffer_h
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef __GNUC__
|
||||
#define __attribute__(x)
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#define ssize_t ptrdiff_t
|
||||
#endif
|
||||
|
||||
class StreamBuffer
|
||||
{
|
||||
char local[64];
|
||||
long len;
|
||||
long cap;
|
||||
long offs;
|
||||
size_t len;
|
||||
size_t cap;
|
||||
size_t offs;
|
||||
char* buffer;
|
||||
|
||||
void init(const void* s, long minsize);
|
||||
void init(const void* s, ssize_t minsize);
|
||||
|
||||
void check(long size)
|
||||
void check(size_t size)
|
||||
{if (len+offs+size >= cap) grow(len+size);}
|
||||
|
||||
void grow(long minsize);
|
||||
void grow(size_t minsize);
|
||||
|
||||
public:
|
||||
// Hints:
|
||||
// * Any index parameter (long) can be negative
|
||||
// * Any index parameter (ssize_t) can be negative
|
||||
// meaning "count from end" (-1 is the last byte)
|
||||
// * Appending negative count deletes from end
|
||||
// * Any returned char* pointer becomes invalid when
|
||||
@ -54,7 +59,7 @@ public:
|
||||
StreamBuffer()
|
||||
{init(NULL, 0);}
|
||||
|
||||
StreamBuffer(const void* s, long size)
|
||||
StreamBuffer(const void* s, ssize_t size)
|
||||
{init(s, size);}
|
||||
|
||||
StreamBuffer(const char* s)
|
||||
@ -63,24 +68,24 @@ public:
|
||||
StreamBuffer(const StreamBuffer& s)
|
||||
{init(s.buffer+s.offs, s.len);}
|
||||
|
||||
StreamBuffer(long size)
|
||||
StreamBuffer(ssize_t size)
|
||||
{init(NULL, size);}
|
||||
|
||||
~StreamBuffer()
|
||||
{if (buffer != local) delete buffer;}
|
||||
|
||||
// operator (): get char* pointing to index
|
||||
const char* operator()(long index=0) const
|
||||
const char* operator()(ssize_t index=0) const
|
||||
{return buffer+offs+(index<0?index+len:index);}
|
||||
|
||||
char* operator()(long index=0)
|
||||
char* operator()(ssize_t index=0)
|
||||
{return buffer+offs+(index<0?index+len:index);}
|
||||
|
||||
// operator []: get byte at index
|
||||
char operator[](long index) const
|
||||
char operator[](ssize_t index) const
|
||||
{return buffer[offs+(index<0?index+len:index)];}
|
||||
|
||||
char& operator[](long index)
|
||||
char& operator[](ssize_t index)
|
||||
{return buffer[offs+(index<0?index+len:index)];}
|
||||
|
||||
// cast to bool: not empty?
|
||||
@ -88,11 +93,11 @@ public:
|
||||
{return len>0;}
|
||||
|
||||
// length: get current data length
|
||||
long length() const
|
||||
ssize_t length() const
|
||||
{return len;}
|
||||
|
||||
// capacity: get current max data length (spare one byte for end)
|
||||
long capacity() const
|
||||
ssize_t capacity() const
|
||||
{return cap-1;}
|
||||
|
||||
// end: get pointer to byte after last data byte
|
||||
@ -105,19 +110,19 @@ public:
|
||||
|
||||
// reserve: reserve size bytes of memory and return
|
||||
// pointer to that memory (for copying something to it)
|
||||
char* reserve(long size)
|
||||
char* reserve(size_t size)
|
||||
{check(size); char* p=buffer+offs+len; len+=size; return p;}
|
||||
|
||||
// append: append data at the end of the buffer
|
||||
StreamBuffer& append(char c)
|
||||
{check(1); buffer[offs+len++]=c; return *this;}
|
||||
|
||||
StreamBuffer& append(char c, long count)
|
||||
StreamBuffer& append(char c, ssize_t count)
|
||||
{if (count < 0) truncate(count);
|
||||
else {check(count); memset(buffer+offs+len, c, count); len+=count;}
|
||||
return *this;}
|
||||
|
||||
StreamBuffer& append(const void* s, long size);
|
||||
StreamBuffer& append(const void* s, ssize_t size);
|
||||
|
||||
StreamBuffer& append(const char* s)
|
||||
{return append(s, s?strlen(s):0);}
|
||||
@ -125,7 +130,7 @@ public:
|
||||
StreamBuffer& append(const StreamBuffer& s)
|
||||
{return append(s.buffer+s.offs, s.len);}
|
||||
|
||||
// operator += alias for set
|
||||
// operator += alias for append
|
||||
StreamBuffer& operator+=(char c)
|
||||
{return append(c);}
|
||||
|
||||
@ -136,7 +141,7 @@ public:
|
||||
{return append(s);}
|
||||
|
||||
// set: clear buffer and fill with new data
|
||||
StreamBuffer& set(const void* s, long size)
|
||||
StreamBuffer& set(const void* s, size_t size)
|
||||
{clear(); return append(s, size);}
|
||||
|
||||
StreamBuffer& set(const char* s)
|
||||
@ -154,61 +159,61 @@ public:
|
||||
|
||||
// replace: delete part of buffer (pos/length) and insert new data
|
||||
StreamBuffer& replace(
|
||||
long pos, long length, const void* s, long size);
|
||||
ssize_t pos, ssize_t length, const void* s, ssize_t size);
|
||||
|
||||
StreamBuffer& replace(long pos, long length, const char* s)
|
||||
StreamBuffer& replace(ssize_t pos, ssize_t length, const char* s)
|
||||
{return replace(pos, length, s, s?strlen(s):0);}
|
||||
|
||||
StreamBuffer& replace(long pos, long length, const StreamBuffer& s)
|
||||
StreamBuffer& replace(ssize_t pos, ssize_t length, const StreamBuffer& s)
|
||||
{return replace(pos, length, s.buffer+s.offs, s.len);}
|
||||
|
||||
// remove: delete from start/pos
|
||||
StreamBuffer& remove(long pos, long length)
|
||||
StreamBuffer& remove(ssize_t pos, ssize_t length)
|
||||
{return replace(pos, length, NULL, 0);}
|
||||
|
||||
// remove from start: no memset, no function call, fast!
|
||||
StreamBuffer& remove(long length)
|
||||
StreamBuffer& remove(size_t length)
|
||||
{if (length>len) length=len;
|
||||
offs+=length; len-=length; return *this;}
|
||||
|
||||
// truncate: delete end of buffer
|
||||
StreamBuffer& truncate(long pos)
|
||||
StreamBuffer& truncate(ssize_t pos)
|
||||
{return replace(pos, len, NULL, 0);}
|
||||
|
||||
// insert: insert new data into buffer
|
||||
StreamBuffer& insert(long pos, const void* s, long size)
|
||||
StreamBuffer& insert(ssize_t pos, const void* s, ssize_t size)
|
||||
{return replace(pos, 0, s, size);}
|
||||
|
||||
StreamBuffer& insert(long pos, const char* s)
|
||||
StreamBuffer& insert(ssize_t pos, const char* s)
|
||||
{return replace(pos, 0, s, s?strlen(s):0);}
|
||||
|
||||
StreamBuffer& insert(long pos, const StreamBuffer& s)
|
||||
StreamBuffer& insert(ssize_t pos, const StreamBuffer& s)
|
||||
{return replace(pos, 0, s.buffer+s.offs, s.len);}
|
||||
|
||||
StreamBuffer& insert(long pos, char c)
|
||||
StreamBuffer& insert(ssize_t pos, char c)
|
||||
{return replace(pos, 0, &c, 1);}
|
||||
|
||||
StreamBuffer& print(const char* fmt, ...)
|
||||
__attribute__ ((format(printf,2,3)));
|
||||
|
||||
// find: get index of data in buffer or -1
|
||||
long find(char c, long start=0) const
|
||||
ssize_t find(char c, ssize_t start=0) const
|
||||
{char* p;
|
||||
return (p = static_cast<char*>(
|
||||
memchr(buffer+offs+(start<0?start+len:start),
|
||||
c, start<0?-start:len-start)))?
|
||||
p-(buffer+offs) : -1;}
|
||||
|
||||
long find(const void* s, long size, long start=0) const;
|
||||
ssize_t find(const void* s, size_t size, ssize_t start=0) const;
|
||||
|
||||
long find(const char* s, long start=0) const
|
||||
ssize_t find(const char* s, ssize_t start=0) const
|
||||
{return find(s, s?strlen(s):0, start);}
|
||||
|
||||
long int find(const StreamBuffer& s, long start=0) const
|
||||
ssize_t find(const StreamBuffer& s, ssize_t start=0) const
|
||||
{return find(s.buffer+s.offs, s.len, start);}
|
||||
|
||||
// startswith: returns true if first size bytes are equal
|
||||
bool startswith(const void* s, long size) const
|
||||
bool startswith(const void* s, size_t size) const
|
||||
{return len>=size ? memcmp(buffer+offs, s, size) == 0 : false;}
|
||||
|
||||
// startswith: returns true if first string is equal (empty string matches)
|
||||
@ -217,9 +222,9 @@ public:
|
||||
|
||||
// expand: create copy of StreamBuffer where all nonprintable characters
|
||||
// are replaced by <xx> with xx being the hex code of the characters
|
||||
StreamBuffer expand(long start, long length) const;
|
||||
StreamBuffer expand(ssize_t start, ssize_t length) const;
|
||||
|
||||
StreamBuffer expand(long start=0) const
|
||||
StreamBuffer expand(ssize_t start=0) const
|
||||
{return expand(start, len);}
|
||||
|
||||
// dump: debug function, like expand but also show the 'hidden' memory
|
||||
@ -227,4 +232,13 @@ public:
|
||||
StreamBuffer dump() const;
|
||||
};
|
||||
|
||||
// printf size prefix for size_t and ssize_t
|
||||
#if defined (__GNUC__) && __GNUC__ >= 3
|
||||
#define PRINTF_SIZE_T_PREFIX "z"
|
||||
#elif defined (_WIN32)
|
||||
#define PRINTF_SIZE_T_PREFIX "I"
|
||||
#else
|
||||
#define PRINTF_SIZE_T_PREFIX ""
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -18,14 +18,9 @@
|
||||
***************************************************************/
|
||||
|
||||
#include "StreamBusInterface.h"
|
||||
#include "StreamError.h"
|
||||
|
||||
const char* StreamIoStatusStr[] = {
|
||||
"StreamIoSuccess",
|
||||
"StreamIoTimeout",
|
||||
"StreamIoNoReply",
|
||||
"StreamIoEnd",
|
||||
"StreamIoFault"
|
||||
};
|
||||
StreamIoStatusStrClass StreamIoStatusStr;
|
||||
|
||||
StreamBusInterfaceRegistrarBase* StreamBusInterfaceRegistrarBase::first;
|
||||
|
||||
@ -64,11 +59,17 @@ supportsAsyncRead()
|
||||
StreamBusInterface* StreamBusInterface::
|
||||
find(Client* client, const char* busname, int addr, const char* param)
|
||||
{
|
||||
debug("StreamBusInterface::find(%s, %s, %d, \"%s\")\n",
|
||||
client->name(), busname, addr, param);
|
||||
StreamBusInterfaceRegistrarBase* r;
|
||||
StreamBusInterface* bus;
|
||||
for (r = r->first; r; r = r->next)
|
||||
for (r = StreamBusInterfaceRegistrarBase::first; r; r = r->next)
|
||||
{
|
||||
debug("StreamBusInterface::find %s check %s\n",
|
||||
client->name(), r->name);
|
||||
bus = r->find(client, busname, addr, param);
|
||||
debug("StreamBusInterface::find %s %s\n",
|
||||
r->name, bus ? "matches" : "does not match");
|
||||
if (bus) return bus;
|
||||
}
|
||||
return NULL;
|
||||
|
||||
@ -21,13 +21,26 @@
|
||||
#define StreamBusInterface_h
|
||||
|
||||
#include <stddef.h>
|
||||
#include <StreamBuffer.h>
|
||||
|
||||
enum StreamIoStatus {
|
||||
StreamIoSuccess, StreamIoTimeout, StreamIoNoReply,
|
||||
StreamIoEnd, StreamIoFault
|
||||
};
|
||||
|
||||
extern const char* StreamIoStatusStr[];
|
||||
class StreamIoStatusStrClass {
|
||||
public:
|
||||
const char* operator [] (int index) {
|
||||
switch (index) {
|
||||
case StreamIoSuccess: return "StreamIoSuccess";
|
||||
case StreamIoTimeout: return "StreamIoTimeout";
|
||||
case StreamIoNoReply: return "StreamIoNoReply";
|
||||
case StreamIoEnd: return "StreamIoEnd";
|
||||
case StreamIoFault: return "StreamIoFault";
|
||||
default: return "illegal status";
|
||||
}
|
||||
}
|
||||
} extern StreamIoStatusStr;
|
||||
|
||||
class StreamBusInterface
|
||||
{
|
||||
@ -44,70 +57,53 @@ public:
|
||||
virtual void connectCallback(StreamIoStatus status);
|
||||
virtual void disconnectCallback(StreamIoStatus status);
|
||||
virtual long priority();
|
||||
virtual const char* name() = 0;
|
||||
virtual const char* getInTerminator(size_t& length) = 0;
|
||||
virtual const char* getOutTerminator(size_t& length) = 0;
|
||||
public:
|
||||
virtual const char* name() = 0;
|
||||
virtual ~Client();
|
||||
protected:
|
||||
StreamBusInterface* businterface;
|
||||
bool busSupportsEvent() {
|
||||
if (businterface)
|
||||
return businterface->supportsEvent();
|
||||
else return false;
|
||||
return businterface && businterface->supportsEvent();
|
||||
}
|
||||
bool busSupportsAsyncRead() {
|
||||
if (businterface)
|
||||
return businterface->supportsAsyncRead();
|
||||
else return false;
|
||||
return businterface && businterface->supportsAsyncRead();
|
||||
}
|
||||
bool busAcceptEvent(unsigned long mask,
|
||||
unsigned long replytimeout_ms) {
|
||||
if (businterface)
|
||||
return businterface->acceptEvent(mask, replytimeout_ms);
|
||||
else return false;
|
||||
return businterface && businterface->acceptEvent(mask, replytimeout_ms);
|
||||
}
|
||||
void busRelease() {
|
||||
if (businterface)
|
||||
businterface->release();
|
||||
if (businterface) businterface->release();
|
||||
}
|
||||
bool busLockRequest(unsigned long timeout_ms) {
|
||||
if (businterface)
|
||||
return businterface->lockRequest(timeout_ms);
|
||||
else return false;
|
||||
return businterface && businterface->lockRequest(timeout_ms);
|
||||
}
|
||||
bool busUnlock() {
|
||||
if (businterface)
|
||||
return businterface->unlock();
|
||||
else return false;
|
||||
return businterface && businterface->unlock();
|
||||
}
|
||||
bool busWriteRequest(const void* output, size_t size,
|
||||
unsigned long timeout_ms) {
|
||||
if (businterface)
|
||||
return businterface->writeRequest(output, size, timeout_ms);
|
||||
else return false;
|
||||
return businterface && businterface->writeRequest(output, size, timeout_ms);
|
||||
}
|
||||
bool busReadRequest(unsigned long replytimeout_ms,
|
||||
unsigned long readtimeout_ms, long expectedLength,
|
||||
bool async) {
|
||||
if (businterface)
|
||||
return businterface->readRequest(replytimeout_ms,
|
||||
return businterface && businterface->readRequest(replytimeout_ms,
|
||||
readtimeout_ms, expectedLength, async);
|
||||
else return false;
|
||||
}
|
||||
void busFinish() {
|
||||
if (businterface)
|
||||
businterface->finish();
|
||||
if (businterface) businterface->finish();
|
||||
}
|
||||
bool busConnectRequest(unsigned long timeout_ms) {
|
||||
if (businterface)
|
||||
return businterface->connectRequest(timeout_ms);
|
||||
else return false;
|
||||
return businterface && businterface->connectRequest(timeout_ms);
|
||||
}
|
||||
bool busDisconnect() {
|
||||
if (businterface)
|
||||
return businterface->disconnectRequest();
|
||||
else return false;
|
||||
return businterface && businterface->disconnectRequest();
|
||||
}
|
||||
void busPrintStatus(StreamBuffer& buffer) {
|
||||
if (businterface) businterface->printStatus(buffer);
|
||||
}
|
||||
};
|
||||
|
||||
@ -157,6 +153,7 @@ protected:
|
||||
virtual bool connectRequest(unsigned long connecttimeout_ms);
|
||||
virtual bool disconnectRequest();
|
||||
virtual void finish();
|
||||
virtual void printStatus(StreamBuffer& buffer) {};
|
||||
|
||||
// pure virtual
|
||||
virtual bool lockRequest(unsigned long timeout_ms) = 0;
|
||||
|
||||
@ -23,6 +23,8 @@
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define P PRINTF_SIZE_T_PREFIX
|
||||
|
||||
enum Commands { end_cmd, in_cmd, out_cmd, wait_cmd, event_cmd, exec_cmd,
|
||||
connect_cmd, disconnect_cmd };
|
||||
const char* commandStr[] = { "end", "in", "out", "wait", "event", "exec",
|
||||
@ -163,7 +165,7 @@ attachBus(const char* busname, int addr, const char* param)
|
||||
businterface = StreamBusInterface::find(this, busname, addr, param);
|
||||
if (!businterface)
|
||||
{
|
||||
error("Businterface '%s' not found for '%s'\n",
|
||||
error("Cannot find a bus named '%s' for '%s'\n",
|
||||
busname, name());
|
||||
return false;
|
||||
}
|
||||
@ -341,6 +343,7 @@ compileCommand(StreamProtocolParser::Protocol* protocol,
|
||||
return false;
|
||||
}
|
||||
args++;
|
||||
while (isspace(*args)) args++;
|
||||
}
|
||||
buffer.append(&eventmask, sizeof(eventmask));
|
||||
if (*args)
|
||||
@ -815,7 +818,7 @@ lockCallback(StreamIoStatus status)
|
||||
{
|
||||
MutexLock lock(this);
|
||||
debug("StreamCore::lockCallback(%s, status=%s)\n",
|
||||
name(), status ? "Timeout" : "Success");
|
||||
name(), StreamIoStatusStr[status]);
|
||||
if (!(flags & LockPending))
|
||||
{
|
||||
error("StreamCore::lockCallback(%s) called unexpectedly\n",
|
||||
@ -829,9 +832,21 @@ lockCallback(StreamIoStatus status)
|
||||
case StreamIoSuccess:
|
||||
break;
|
||||
case StreamIoTimeout:
|
||||
error("%s: Cannot lock device within %ld ms, device seems to be busy\n",
|
||||
name(), lockTimeout);
|
||||
flags &= ~BusOwner;
|
||||
finishProtocol(LockTimeout);
|
||||
return;
|
||||
case StreamIoFault:
|
||||
error("%s: Locking failed because of a device fault\n",
|
||||
name());
|
||||
flags &= ~BusOwner;
|
||||
finishProtocol(LockTimeout);
|
||||
return;
|
||||
default:
|
||||
error("StreamCore::lockCallback(%s) unexpected status %s\n",
|
||||
name(), StreamIoStatusStr[status]);
|
||||
flags &= ~BusOwner;
|
||||
finishProtocol(Fault);
|
||||
return;
|
||||
}
|
||||
@ -982,7 +997,7 @@ readCallback(StreamIoStatus status,
|
||||
finishProtocol(ReplyTimeout);
|
||||
return 0;
|
||||
case StreamIoFault:
|
||||
error("%s: I/O error after reading %ld byte%s: \"%s%s\"\n",
|
||||
error("%s: I/O error after reading %"P"d byte%s: \"%s%s\"\n",
|
||||
name(),
|
||||
inputBuffer.length(), inputBuffer.length()==1 ? "" : "s",
|
||||
inputBuffer.length() > 20 ? "..." : "",
|
||||
@ -991,7 +1006,7 @@ readCallback(StreamIoStatus status,
|
||||
return 0;
|
||||
}
|
||||
inputBuffer.append(input, size);
|
||||
debug("StreamCore::readCallback(%s) inputBuffer=\"%s\", size %ld\n",
|
||||
debug("StreamCore::readCallback(%s) inputBuffer=\"%s\", size %"P"d\n",
|
||||
name(), inputBuffer.expand()(), inputBuffer.length());
|
||||
if (*activeCommand != in_cmd)
|
||||
{
|
||||
@ -1184,6 +1199,7 @@ normal_format:
|
||||
int consumed;
|
||||
// code layout:
|
||||
// formatstring <eos> StreamFormat [info]
|
||||
formatstring.clear();
|
||||
commandIndex = StreamProtocolParser::printString(formatstring, commandIndex);
|
||||
|
||||
StreamFormat fmt = extract<StreamFormat>(commandIndex);
|
||||
@ -1303,8 +1319,8 @@ normal_format:
|
||||
inputLine.length()-consumedInput > 20 ? "..." : "",
|
||||
formatstring());
|
||||
else
|
||||
error("%s: Format \"%%%s\" has data type %s which does not match variable \"%s\".\n",
|
||||
name(), formatstring(), StreamFormatTypeStr[fmt.type], fieldName);
|
||||
error("%s: Format \"%%%s\" has data type %s which does not match the type of \"%s\".\n",
|
||||
name(), formatstring(), StreamFormatTypeStr[fmt.type], fieldAddress ? fieldName : name());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -1734,4 +1750,25 @@ disconnectCallback(StreamIoStatus status)
|
||||
}
|
||||
}
|
||||
|
||||
void StreamCore::
|
||||
printStatus(StreamBuffer& buffer)
|
||||
{
|
||||
buffer.print("active command=%s ",
|
||||
activeCommand ? commandName(*activeCommand) : "NULL");
|
||||
buffer.print("flags=0x%04lx ", flags);
|
||||
if (flags & IgnoreExtraInput) buffer.append("IgnoreExtraInput ");
|
||||
if (flags & InitRun) buffer.append("InitRun ");
|
||||
if (flags & AsyncMode) buffer.append("AsyncMode ");
|
||||
if (flags & GotValue) buffer.append("GotValue ");
|
||||
if (flags & BusOwner) buffer.append("BusOwner ");
|
||||
if (flags & Separator) buffer.append("Separator ");
|
||||
if (flags & ScanTried) buffer.append("ScanTried ");
|
||||
if (flags & AcceptInput) buffer.append("AcceptInput ");
|
||||
if (flags & AcceptEvent) buffer.append("AcceptEvent ");
|
||||
if (flags & LockPending) buffer.append("LockPending ");
|
||||
if (flags & WritePending) buffer.append("WritePending ");
|
||||
if (flags & WaitPending) buffer.append("WaitPending ");
|
||||
busPrintStatus(buffer);
|
||||
}
|
||||
|
||||
#include "streamReferences"
|
||||
|
||||
@ -219,6 +219,7 @@ public:
|
||||
bool parse(const char* filename, const char* protocolname);
|
||||
void printProtocol();
|
||||
const char* name() { return streamname; }
|
||||
void printStatus(StreamBuffer& buffer);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -18,7 +18,9 @@
|
||||
* *
|
||||
***************************************************************/
|
||||
|
||||
#define epicsExportSharedSymbols
|
||||
#include "devStream.h"
|
||||
#undef epicsExportSharedSymbols
|
||||
#include "StreamCore.h"
|
||||
#include "StreamError.h"
|
||||
|
||||
@ -31,6 +33,9 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define epicsAlarmGLOBAL
|
||||
#include <alarm.h>
|
||||
#undef epicsAlarmGLOBAL
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
@ -39,8 +44,6 @@ extern "C" {
|
||||
#include <recSup.h>
|
||||
#include <recGbl.h>
|
||||
#include <devLib.h>
|
||||
#define epicsAlarmGLOBAL
|
||||
#include <alarm.h>
|
||||
#include <callback.h>
|
||||
|
||||
#ifdef EPICS_3_13
|
||||
@ -347,6 +350,12 @@ report(int interest)
|
||||
{
|
||||
printf(" %s: %s\n", pstream->name(),
|
||||
pstream->ioLink->value.instio.string);
|
||||
if (interest == 3)
|
||||
{
|
||||
StreamBuffer buffer;
|
||||
pstream->printStatus(buffer);
|
||||
printf(" %s\n", buffer());
|
||||
}
|
||||
}
|
||||
}
|
||||
return OK;
|
||||
@ -419,26 +428,35 @@ long streamInitRecord(dbCommon* record, const struct link *ioLink,
|
||||
if (!pstream)
|
||||
{
|
||||
// initialize the first time
|
||||
debug("streamInitRecord(%s): create new Stream object\n",
|
||||
record->name);
|
||||
pstream = new Stream(record, ioLink, readData, writeData);
|
||||
record->dpvt = pstream;
|
||||
} else {
|
||||
// stop any running protocol
|
||||
debug("streamInitRecord(%s): stop running protocol\n",
|
||||
record->name);
|
||||
pstream->finishProtocol(Stream::Abort);
|
||||
}
|
||||
// scan the i/o link
|
||||
debug("streamInitRecord(%s): parse link \"%s\"\n",
|
||||
record->name, ioLink->value.instio.string);
|
||||
pstream->parseLink(ioLink, filename, protocol,
|
||||
busname, &addr, busparam);
|
||||
// (re)initialize bus and protocol
|
||||
debug("streamInitRecord(%s): calling initRecord\n",
|
||||
record->name);
|
||||
long status = pstream->initRecord(filename, protocol,
|
||||
busname, addr, busparam);
|
||||
if (status != OK && status != DO_NOT_CONVERT)
|
||||
{
|
||||
error("%s: Record initialization failed\n", record->name);
|
||||
}
|
||||
if (!pstream->ioscanpvt)
|
||||
else if (!pstream->ioscanpvt)
|
||||
{
|
||||
scanIoInit(&pstream->ioscanpvt);
|
||||
}
|
||||
debug("streamInitRecord(%s) done status=%#lx\n", record->name, status);
|
||||
return status;
|
||||
}
|
||||
|
||||
@ -608,6 +626,8 @@ initRecord(const char* filename, const char* protocol,
|
||||
// It is safe to call this function again with different arguments
|
||||
|
||||
// attach to bus interface
|
||||
debug("Stream::initRecord %s: attachBus(%s, %d, \"%s\")\n",
|
||||
name(), busname, addr, busparam);
|
||||
if (!attachBus(busname, addr, busparam))
|
||||
{
|
||||
error("%s: Can't attach to bus %s %d\n",
|
||||
@ -616,6 +636,8 @@ initRecord(const char* filename, const char* protocol,
|
||||
}
|
||||
|
||||
// parse protocol file
|
||||
debug("Stream::initRecord %s: parse(%s, %s)\n",
|
||||
name(), filename, protocol);
|
||||
if (!parse(filename, protocol))
|
||||
{
|
||||
error("%s: Protocol parse error\n",
|
||||
|
||||
@ -1037,7 +1037,7 @@ compileNumber(unsigned long& number, const char*& source, unsigned long max)
|
||||
"Garbage after numeric value: %s\n", buffer());
|
||||
return false;
|
||||
}
|
||||
if (n < 0 || n > max)
|
||||
if (n > max)
|
||||
{
|
||||
debug("StreamProtocolParser::Protocol::compileNumber: %s\n",
|
||||
buffer.expand()());
|
||||
|
||||
@ -22,8 +22,8 @@
|
||||
#define devStream_h
|
||||
|
||||
#define STREAM_MAJOR 2
|
||||
#define STREAM_MINOR 5
|
||||
#define STREAM_PATCHLEVEL 12
|
||||
#define STREAM_MINOR 6
|
||||
#define STREAM_PATCHLEVEL 4
|
||||
|
||||
#if defined(__vxworks) || defined(vxWorks)
|
||||
#include <vxWorks.h>
|
||||
@ -41,7 +41,7 @@
|
||||
#define INIT_RUN (!interruptAccept)
|
||||
|
||||
#include <epicsVersion.h>
|
||||
#ifdef BASE_RELEASE
|
||||
#ifdef BASE_VERSION
|
||||
#define EPICS_3_13
|
||||
#endif
|
||||
|
||||
@ -49,6 +49,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef epicsExportSharedSymbols
|
||||
# define devStream_epicsExportSharedSymbols
|
||||
# undef epicsExportSharedSymbols
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <dbCommon.h>
|
||||
#include <dbScan.h>
|
||||
@ -56,6 +61,11 @@ extern "C" {
|
||||
/* #include <dbFldTypes.h> */
|
||||
#include <dbAccess.h>
|
||||
|
||||
#ifdef devStream_epicsExportSharedSymbols
|
||||
# define epicsExportSharedSymbols
|
||||
# include "shareLib.h"
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus) && defined(EPICS_3_13)
|
||||
}
|
||||
#endif
|
||||
@ -76,16 +86,16 @@ extern const char StreamVersion [];
|
||||
|
||||
typedef long (*streamIoFunction) (dbCommon*, format_t*);
|
||||
|
||||
epicsShareExtern long streamInit(int after);
|
||||
epicsShareExtern long streamInitRecord(dbCommon *record,
|
||||
epicsShareFunc long streamInit(int after);
|
||||
epicsShareFunc long streamInitRecord(dbCommon *record,
|
||||
const struct link *ioLink,
|
||||
streamIoFunction readData, streamIoFunction writeData);
|
||||
epicsShareExtern long streamReport(int interest);
|
||||
epicsShareExtern long streamReadWrite(dbCommon *record);
|
||||
epicsShareExtern long streamGetIointInfo(int cmd,
|
||||
epicsShareFunc long streamReport(int interest);
|
||||
epicsShareFunc long streamReadWrite(dbCommon *record);
|
||||
epicsShareFunc long streamGetIointInfo(int cmd,
|
||||
dbCommon *record, IOSCANPVT *ppvt);
|
||||
epicsShareExtern long streamPrintf(dbCommon *record, format_t *format, ...);
|
||||
epicsShareExtern long streamScanfN(dbCommon *record, format_t *format,
|
||||
epicsShareFunc long streamPrintf(dbCommon *record, format_t *format, ...);
|
||||
epicsShareFunc long streamScanfN(dbCommon *record, format_t *format,
|
||||
void*, size_t maxStringSize);
|
||||
|
||||
/* backward compatibility stuff */
|
||||
|
||||
@ -31,9 +31,11 @@ PROD_LIBS = stream
|
||||
ifdef ASYN
|
||||
# edit asynRegistrars.dbd if necessary
|
||||
streamApp_DBD += asynRegistrars.dbd
|
||||
# add asyn.dbd if you want to have asyn Record and asyn device supports
|
||||
# streamApp_DBD += asyn.dbd
|
||||
# add asynRecord.dbd if you like
|
||||
streamApp_DBD += asynRecord.dbd
|
||||
PROD_LIBS += asyn
|
||||
# cygwin needs separate RPC library for asyn
|
||||
PROD_SYS_LIBS_cygwin32 += $(CYGWIN_RPC_LIB)
|
||||
endif
|
||||
|
||||
ifneq ($(words $(CALC) $(SYNAPPS)), 0)
|
||||
@ -49,7 +51,7 @@ endif
|
||||
streamApp_DBD += stream.dbd
|
||||
|
||||
ifdef PCRE
|
||||
LIB_LIBS += pcre
|
||||
PROD_LIBS += pcre
|
||||
else
|
||||
ifneq ($(words $(PCRE_LIB) $(PCRE_INCLUDE)),0)
|
||||
PROD_SYS_LIBS_DEFAULT += pcre
|
||||
@ -66,7 +68,7 @@ CPPFLAGS += -DDEBUGFILE=StreamDebug.log
|
||||
|
||||
include $(TOP)/configure/RULES
|
||||
|
||||
ifeq ($(EPICS_REVISION),14)
|
||||
ifeq ($(BASE_3_14), YES)
|
||||
clean:: myclean
|
||||
else
|
||||
clean: myclean
|
||||
|
||||
@ -40,11 +40,13 @@ proc escape {string} {
|
||||
}
|
||||
|
||||
proc sendReply {sock text} {
|
||||
.$sock.t mark set insert end
|
||||
.$sock.t insert end $text
|
||||
.$sock.t see end
|
||||
puts -nonewline $sock $text
|
||||
# puts "sending \"[escape $text]\"\n"
|
||||
catch {
|
||||
# ignore that socket may already be closed
|
||||
.$sock.t mark set insert end
|
||||
.$sock.t insert end $text
|
||||
.$sock.t see end
|
||||
puts -nonewline $sock $text
|
||||
}
|
||||
}
|
||||
|
||||
proc checkNum {n} {
|
||||
@ -89,7 +91,7 @@ proc receiveHandler {sock} {
|
||||
"start" {
|
||||
set wait [checkNum [lindex $l 1]]
|
||||
set ::counter 0
|
||||
after $wait sendAsync $wait [list [lrange $l 2 end-1]]
|
||||
after $wait [list sendAsync $wait "[string range $a [string wordend $a 7] end]"]
|
||||
sendReply $sock "Started\n"
|
||||
}
|
||||
"stop" {
|
||||
@ -131,7 +133,7 @@ proc receiveHandler {sock} {
|
||||
proc sendAsync {wait message} {
|
||||
if {$::counter < 0} return
|
||||
foreach term [array names ::socket] {
|
||||
sendReply $::socket($term) "Message number [incr ::counter] $message\n";
|
||||
sendReply $::socket($term) "Message number [incr ::counter]$message";
|
||||
}
|
||||
after $wait sendAsync $wait [list $message]
|
||||
}
|
||||
|
||||
@ -41,7 +41,7 @@ proc receiveHandler {sock} {
|
||||
}
|
||||
|
||||
proc startioc {} {
|
||||
global debug records protocol startup port sock ioc testname env streamversion
|
||||
global debug records protocol startup port sock ioc testname env streamversion asynversion
|
||||
set fd [open test.db w]
|
||||
puts $fd $records
|
||||
close $fd
|
||||
@ -52,6 +52,9 @@ proc startioc {} {
|
||||
|
||||
if [info exists streamversion] {
|
||||
puts $fd "#!/usr/local/bin/iocsh"
|
||||
if [info exists asynversion] {
|
||||
puts $fd "require asyn,$asynversion"
|
||||
}
|
||||
puts $fd "require stream2,$streamversion"
|
||||
} else {
|
||||
puts $fd "#!../O.$env(EPICS_HOST_ARCH)/streamApp"
|
||||
@ -202,3 +205,7 @@ if {[lindex $argv 0] == "-sls"} {
|
||||
set streamversion [lindex $argv 1]
|
||||
set argv [lrange $argv 2 end]
|
||||
}
|
||||
if {[lindex $argv 0] == "-asyn"} {
|
||||
set asynversion [lindex $argv 1]
|
||||
set argv [lrange $argv 2 end]
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@ source streamtestlib.tcl
|
||||
# Send commands to the ioc shell with ioccmd
|
||||
|
||||
set records {
|
||||
record (ao, "DZ:test1")
|
||||
record (stringout, "DZ:test1")
|
||||
{
|
||||
field (DTYP, "stream")
|
||||
field (OUT, "@test.proto test1 device")
|
||||
@ -15,7 +15,225 @@ set records {
|
||||
}
|
||||
|
||||
set protocol {
|
||||
test1 {out 0x55 0x40 0x04 0x00 0x00 'z;' "%<sum>";}
|
||||
Terminator="\n";
|
||||
test1 {
|
||||
out "sum %s %9.1<sum>"; in "sum %=s %9.1<sum>";
|
||||
out "sum8 %s %9.1<sum8>"; in "sum8 %=s %9.1<sum8>";
|
||||
out "sum16 %s %9.1<sum16>"; in "sum16 %=s %9.1<sum16>";
|
||||
out "sum32 %s %9.1<sum32>"; in "sum32 %=s %9.1<sum32>";
|
||||
out "nsum %s %9.1<nsum>"; in "nsum %=s %9.1<nsum>";
|
||||
out "negsum %s %9.1<negsum>"; in "negsum %=s %9.1<negsum>";
|
||||
out "-sum %s %9.1<-sum>"; in "-sum %=s %9.1<-sum>";
|
||||
out "nsum8 %s %9.1<nsum8>"; in "nsum8 %=s %9.1<nsum8>";
|
||||
out "negsum8 %s %9.1<negsum8>"; in "negsum8 %=s %9.1<negsum8>";
|
||||
out "-sum8 %s %9.1<-sum8>"; in "-sum8 %=s %9.1<-sum8>";
|
||||
out "nsum16 %s %9.1<nsum16>"; in "nsum16 %=s %9.1<nsum16>";
|
||||
out "negsum16 %s %9.1<negsum1>"; in "negsum16 %=s %9.1<negsum1>";
|
||||
out "-sum16 %s %9.1<-sum16>"; in "-sum16 %=s %9.1<-sum16>";
|
||||
out "nsum32 %s %9.1<nsum32>"; in "nsum32 %=s %9.1<nsum32>";
|
||||
out "negsum32 %s %9.1<negsum3>"; in "negsum32 %=s %9.1<negsum3>";
|
||||
out "-sum32 %s %9.1<-sum32>"; in "-sum32 %=s %9.1<-sum32>";
|
||||
out "notsum %s %9.1<notsum>"; in "notsum %=s %9.1<notsum>";
|
||||
out "~sum %s %9.1<~sum>"; in "~sum %=s %9.1<~sum>";
|
||||
out "xor %s %9.1<xor>"; in "xor %=s %9.1<xor>";
|
||||
out "xor8 %s %9.1<xor8>"; in "xor8 %=s %9.1<xor8>";
|
||||
out "xor7 %s %9.1<xor7>"; in "xor7 %=s %9.1<xor7>";
|
||||
out "crc8 %s %9.1<crc8>"; in "crc8 %=s %9.1<crc8>";
|
||||
out "ccitt8 %s %9.1<ccitt8>"; in "ccitt8 %=s %9.1<ccitt8>";
|
||||
out "crc16 %s %9.1<crc16>"; in "crc16 %=s %9.1<crc16>";
|
||||
out "crc16r %s %9.1<crc16r>"; in "crc16r %=s %9.1<crc16r>";
|
||||
out "ccitt16 %s %9.1<ccitt16>"; in "ccitt16 %=s %9.1<ccitt16>";
|
||||
out "ccitt16a %s %9.1<ccitt16a>"; in "ccitt16a %=s %9.1<ccitt16a>";
|
||||
out "ccitt16x %s %9.1<ccitt16x>"; in "ccitt16x %=s %9.1<ccitt16x>";
|
||||
out "crc16c %s %9.1<crc16c>"; in "crc16c %=s %9.1<crc16c>";
|
||||
out "xmodem %s %9.1<xmodem>"; in "xmodem %=s %9.1<xmodem>";
|
||||
out "crc32 %s %9.1<crc32>"; in "crc32 %=s %9.1<crc32>";
|
||||
out "crc32r %s %9.1<crc32r>"; in "crc32r %=s %9.1<crc32r>";
|
||||
out "jamcrc %s %9.1<jamcrc>"; in "jamcrc %=s %9.1<jamcrc>";
|
||||
out "adler32 %s %9.1<adler32>"; in "adler32 %=s %9.1<adler32>";
|
||||
out "hexsum8 %s %9.1<hexsum8>"; in "hexsum8 %=s %9.1<hexsum8>";
|
||||
|
||||
out "sum %s %09.1<sum>"; in "sum %=s %09.1<sum>";
|
||||
out "sum8 %s %09.1<sum8>"; in "sum8 %=s %09.1<sum8>";
|
||||
out "sum16 %s %09.1<sum16>"; in "sum16 %=s %09.1<sum16>";
|
||||
out "sum32 %s %09.1<sum32>"; in "sum32 %=s %09.1<sum32>";
|
||||
out "nsum %s %09.1<nsum>"; in "nsum %=s %09.1<nsum>";
|
||||
out "negsum %s %09.1<negsum>"; in "negsum %=s %09.1<negsum>";
|
||||
out "-sum %s %09.1<-sum>"; in "-sum %=s %09.1<-sum>";
|
||||
out "nsum8 %s %09.1<nsum8>"; in "nsum8 %=s %09.1<nsum8>";
|
||||
out "negsum8 %s %09.1<negsum8>"; in "negsum8 %=s %09.1<negsum8>";
|
||||
out "-sum8 %s %09.1<-sum8>"; in "-sum8 %=s %09.1<-sum8>";
|
||||
out "nsum16 %s %09.1<nsum16>"; in "nsum16 %=s %09.1<nsum16>";
|
||||
out "negsum16 %s %09.1<negsum1>"; in "negsum16 %=s %09.1<negsum1>";
|
||||
out "-sum16 %s %09.1<-sum16>"; in "-sum16 %=s %09.1<-sum16>";
|
||||
out "nsum32 %s %09.1<nsum32>"; in "nsum32 %=s %09.1<nsum32>";
|
||||
out "negsum32 %s %09.1<negsum3>"; in "negsum32 %=s %09.1<negsum3>";
|
||||
out "-sum32 %s %09.1<-sum32>"; in "-sum32 %=s %09.1<-sum32>";
|
||||
out "notsum %s %09.1<notsum>"; in "notsum %=s %09.1<notsum>";
|
||||
out "~sum %s %09.1<~sum>"; in "~sum %=s %09.1<~sum>";
|
||||
out "xor %s %09.1<xor>"; in "xor %=s %09.1<xor>";
|
||||
out "xor8 %s %09.1<xor8>"; in "xor8 %=s %09.1<xor8>";
|
||||
out "xor7 %s %09.1<xor7>"; in "xor7 %=s %09.1<xor7>";
|
||||
out "crc8 %s %09.1<crc8>"; in "crc8 %=s %09.1<crc8>";
|
||||
out "ccitt8 %s %09.1<ccitt8>"; in "ccitt8 %=s %09.1<ccitt8>";
|
||||
out "crc16 %s %09.1<crc16>"; in "crc16 %=s %09.1<crc16>";
|
||||
out "crc16r %s %09.1<crc16r>"; in "crc16r %=s %09.1<crc16r>";
|
||||
out "ccitt16 %s %09.1<ccitt16>"; in "ccitt16 %=s %09.1<ccitt16>";
|
||||
out "ccitt16a %s %09.1<ccitt16a>"; in "ccitt16a %=s %09.1<ccitt16a>";
|
||||
out "ccitt16x %s %09.1<ccitt16x>"; in "ccitt16x %=s %09.1<ccitt16x>";
|
||||
out "crc16c %s %09.1<crc16c>"; in "crc16c %=s %09.1<crc16c>";
|
||||
out "xmodem %s %09.1<xmodem>"; in "xmodem %=s %09.1<xmodem>";
|
||||
out "crc32 %s %09.1<crc32>"; in "crc32 %=s %09.1<crc32>";
|
||||
out "crc32r %s %09.1<crc32r>"; in "crc32r %=s %09.1<crc32r>";
|
||||
out "jamcrc %s %09.1<jamcrc>"; in "jamcrc %=s %09.1<jamcrc>";
|
||||
out "adler32 %s %09.1<adler32>"; in "adler32 %=s %09.1<adler32>";
|
||||
out "hexsum8 %s %09.1<hexsum8>"; in "hexsum8 %=s %09.1<hexsum8>";
|
||||
|
||||
out "sum %s %-9.1<sum>"; in "sum %=s %-9.1<sum>";
|
||||
out "sum8 %s %-9.1<sum8>"; in "sum8 %=s %-9.1<sum8>";
|
||||
out "sum16 %s %-9.1<sum16>"; in "sum16 %=s %-9.1<sum16>";
|
||||
out "sum32 %s %-9.1<sum32>"; in "sum32 %=s %-9.1<sum32>";
|
||||
out "nsum %s %-9.1<nsum>"; in "nsum %=s %-9.1<nsum>";
|
||||
out "negsum %s %-9.1<negsum>"; in "negsum %=s %-9.1<negsum>";
|
||||
out "-sum %s %-9.1<-sum>"; in "-sum %=s %-9.1<-sum>";
|
||||
out "nsum8 %s %-9.1<nsum8>"; in "nsum8 %=s %-9.1<nsum8>";
|
||||
out "negsum8 %s %-9.1<negsum8>"; in "negsum8 %=s %-9.1<negsum8>";
|
||||
out "-sum8 %s %-9.1<-sum8>"; in "-sum8 %=s %-9.1<-sum8>";
|
||||
out "nsum16 %s %-9.1<nsum16>"; in "nsum16 %=s %-9.1<nsum16>";
|
||||
out "negsum16 %s %-9.1<negsum1>"; in "negsum16 %=s %-9.1<negsum1>";
|
||||
out "-sum16 %s %-9.1<-sum16>"; in "-sum16 %=s %-9.1<-sum16>";
|
||||
out "nsum32 %s %-9.1<nsum32>"; in "nsum32 %=s %-9.1<nsum32>";
|
||||
out "negsum32 %s %-9.1<negsum3>"; in "negsum32 %=s %-9.1<negsum3>";
|
||||
out "-sum32 %s %-9.1<-sum32>"; in "-sum32 %=s %-9.1<-sum32>";
|
||||
out "notsum %s %-9.1<notsum>"; in "notsum %=s %-9.1<notsum>";
|
||||
out "~sum %s %-9.1<~sum>"; in "~sum %=s %-9.1<~sum>";
|
||||
out "xor %s %-9.1<xor>"; in "xor %=s %-9.1<xor>";
|
||||
out "xor8 %s %-9.1<xor8>"; in "xor8 %=s %-9.1<xor8>";
|
||||
out "xor7 %s %-9.1<xor7>"; in "xor7 %=s %-9.1<xor7>";
|
||||
out "crc8 %s %-9.1<crc8>"; in "crc8 %=s %-9.1<crc8>";
|
||||
out "ccitt8 %s %-9.1<ccitt8>"; in "ccitt8 %=s %-9.1<ccitt8>";
|
||||
out "crc16 %s %-9.1<crc16>"; in "crc16 %=s %-9.1<crc16>";
|
||||
out "crc16r %s %-9.1<crc16r>"; in "crc16r %=s %-9.1<crc16r>";
|
||||
out "ccitt16 %s %-9.1<ccitt16>"; in "ccitt16 %=s %-9.1<ccitt16>";
|
||||
out "ccitt16a %s %-9.1<ccitt16a>"; in "ccitt16a %=s %-9.1<ccitt16a>";
|
||||
out "ccitt16x %s %-9.1<ccitt16x>"; in "ccitt16x %=s %-9.1<ccitt16x>";
|
||||
out "crc16c %s %-9.1<crc16c>"; in "crc16c %=s %-9.1<crc16c>";
|
||||
out "xmodem %s %-9.1<xmodem>"; in "xmodem %=s %-9.1<xmodem>";
|
||||
out "crc32 %s %-9.1<crc32>"; in "crc32 %=s %-9.1<crc32>";
|
||||
out "crc32r %s %-9.1<crc32r>"; in "crc32r %=s %-9.1<crc32r>";
|
||||
out "jamcrc %s %-9.1<jamcrc>"; in "jamcrc %=s %-9.1<jamcrc>";
|
||||
out "adler32 %s %-9.1<adler32>"; in "adler32 %=s %-9.1<adler32>";
|
||||
out "hexsum8 %s %-9.1<hexsum8>"; in "hexsum8 %=s %-9.1<hexsum8>";
|
||||
|
||||
out "sum %s %#9.1<sum>"; in "sum %=s %#9.1<sum>";
|
||||
out "sum8 %s %#9.1<sum8>"; in "sum8 %=s %#9.1<sum8>";
|
||||
out "sum16 %s %#9.1<sum16>"; in "sum16 %=s %#9.1<sum16>";
|
||||
out "sum32 %s %#9.1<sum32>"; in "sum32 %=s %#9.1<sum32>";
|
||||
out "nsum %s %#9.1<nsum>"; in "nsum %=s %#9.1<nsum>";
|
||||
out "negsum %s %#9.1<negsum>"; in "negsum %=s %#9.1<negsum>";
|
||||
out "-sum %s %#9.1<-sum>"; in "-sum %=s %#9.1<-sum>";
|
||||
out "nsum8 %s %#9.1<nsum8>"; in "nsum8 %=s %#9.1<nsum8>";
|
||||
out "negsum8 %s %#9.1<negsum8>"; in "negsum8 %=s %#9.1<negsum8>";
|
||||
out "-sum8 %s %#9.1<-sum8>"; in "-sum8 %=s %#9.1<-sum8>";
|
||||
out "nsum16 %s %#9.1<nsum16>"; in "nsum16 %=s %#9.1<nsum16>";
|
||||
out "negsum16 %s %#9.1<negsum1>"; in "negsum16 %=s %#9.1<negsum1>";
|
||||
out "-sum16 %s %#9.1<-sum16>"; in "-sum16 %=s %#9.1<-sum16>";
|
||||
out "nsum32 %s %#9.1<nsum32>"; in "nsum32 %=s %#9.1<nsum32>";
|
||||
out "negsum32 %s %#9.1<negsum3>"; in "negsum32 %=s %#9.1<negsum3>";
|
||||
out "-sum32 %s %#9.1<-sum32>"; in "-sum32 %=s %#9.1<-sum32>";
|
||||
out "notsum %s %#9.1<notsum>"; in "notsum %=s %#9.1<notsum>";
|
||||
out "~sum %s %#9.1<~sum>"; in "~sum %=s %#9.1<~sum>";
|
||||
out "xor %s %#9.1<xor>"; in "xor %=s %#9.1<xor>";
|
||||
out "xor8 %s %#9.1<xor8>"; in "xor8 %=s %#9.1<xor8>";
|
||||
out "xor7 %s %#9.1<xor7>"; in "xor7 %=s %#9.1<xor7>";
|
||||
out "crc8 %s %#9.1<crc8>"; in "crc8 %=s %#9.1<crc8>";
|
||||
out "ccitt8 %s %#9.1<ccitt8>"; in "ccitt8 %=s %#9.1<ccitt8>";
|
||||
out "crc16 %s %#9.1<crc16>"; in "crc16 %=s %#9.1<crc16>";
|
||||
out "crc16r %s %#9.1<crc16r>"; in "crc16r %=s %#9.1<crc16r>";
|
||||
out "ccitt16 %s %#9.1<ccitt16>"; in "ccitt16 %=s %#9.1<ccitt16>";
|
||||
out "ccitt16a %s %#9.1<ccitt16a>"; in "ccitt16a %=s %#9.1<ccitt16a>";
|
||||
out "ccitt16x %s %#9.1<ccitt16x>"; in "ccitt16x %=s %#9.1<ccitt16x>";
|
||||
out "crc16c %s %#9.1<crc16c>"; in "crc16c %=s %#9.1<crc16c>";
|
||||
out "xmodem %s %#9.1<xmodem>"; in "xmodem %=s %#9.1<xmodem>";
|
||||
out "crc32 %s %#9.1<crc32>"; in "crc32 %=s %#9.1<crc32>";
|
||||
out "crc32r %s %#9.1<crc32r>"; in "crc32r %=s %#9.1<crc32r>";
|
||||
out "jamcrc %s %#9.1<jamcrc>"; in "jamcrc %=s %#9.1<jamcrc>";
|
||||
out "adler32 %s %#9.1<adler32>"; in "adler32 %=s %#9.1<adler32>";
|
||||
out "hexsum8 %s %#9.1<hexsum8>"; in "hexsum8 %=s %#9.1<hexsum8>";
|
||||
|
||||
out "sum %s %#09.1<sum>"; in "sum %=s %#09.1<sum>";
|
||||
out "sum8 %s %#09.1<sum8>"; in "sum8 %=s %#09.1<sum8>";
|
||||
out "sum16 %s %#09.1<sum16>"; in "sum16 %=s %#09.1<sum16>";
|
||||
out "sum32 %s %#09.1<sum32>"; in "sum32 %=s %#09.1<sum32>";
|
||||
out "nsum %s %#09.1<nsum>"; in "nsum %=s %#09.1<nsum>";
|
||||
out "negsum %s %#09.1<negsum>"; in "negsum %=s %#09.1<negsum>";
|
||||
out "-sum %s %#09.1<-sum>"; in "-sum %=s %#09.1<-sum>";
|
||||
out "nsum8 %s %#09.1<nsum8>"; in "nsum8 %=s %#09.1<nsum8>";
|
||||
out "negsum8 %s %#09.1<negsum8>"; in "negsum8 %=s %#09.1<negsum8>";
|
||||
out "-sum8 %s %#09.1<-sum8>"; in "-sum8 %=s %#09.1<-sum8>";
|
||||
out "nsum16 %s %#09.1<nsum16>"; in "nsum16 %=s %#09.1<nsum16>";
|
||||
out "negsum16 %s %#09.1<negsum1>"; in "negsum16 %=s %#09.1<negsum1>";
|
||||
out "-sum16 %s %#09.1<-sum16>"; in "-sum16 %=s %#09.1<-sum16>";
|
||||
out "nsum32 %s %#09.1<nsum32>"; in "nsum32 %=s %#09.1<nsum32>";
|
||||
out "negsum32 %s %#09.1<negsum3>"; in "negsum32 %=s %#09.1<negsum3>";
|
||||
out "-sum32 %s %#09.1<-sum32>"; in "-sum32 %=s %#09.1<-sum32>";
|
||||
out "notsum %s %#09.1<notsum>"; in "notsum %=s %#09.1<notsum>";
|
||||
out "~sum %s %#09.1<~sum>"; in "~sum %=s %#09.1<~sum>";
|
||||
out "xor %s %#09.1<xor>"; in "xor %=s %#09.1<xor>";
|
||||
out "xor8 %s %#09.1<xor8>"; in "xor8 %=s %#09.1<xor8>";
|
||||
out "xor7 %s %#09.1<xor7>"; in "xor7 %=s %#09.1<xor7>";
|
||||
out "crc8 %s %#09.1<crc8>"; in "crc8 %=s %#09.1<crc8>";
|
||||
out "ccitt8 %s %#09.1<ccitt8>"; in "ccitt8 %=s %#09.1<ccitt8>";
|
||||
out "crc16 %s %#09.1<crc16>"; in "crc16 %=s %#09.1<crc16>";
|
||||
out "crc16r %s %#09.1<crc16r>"; in "crc16r %=s %#09.1<crc16r>";
|
||||
out "ccitt16 %s %#09.1<ccitt16>"; in "ccitt16 %=s %#09.1<ccitt16>";
|
||||
out "ccitt16a %s %#09.1<ccitt16a>"; in "ccitt16a %=s %#09.1<ccitt16a>";
|
||||
out "ccitt16x %s %#09.1<ccitt16x>"; in "ccitt16x %=s %#09.1<ccitt16x>";
|
||||
out "crc16c %s %#09.1<crc16c>"; in "crc16c %=s %#09.1<crc16c>";
|
||||
out "xmodem %s %#09.1<xmodem>"; in "xmodem %=s %#09.1<xmodem>";
|
||||
out "crc32 %s %#09.1<crc32>"; in "crc32 %=s %#09.1<crc32>";
|
||||
out "crc32r %s %#09.1<crc32r>"; in "crc32r %=s %#09.1<crc32r>";
|
||||
out "jamcrc %s %#09.1<jamcrc>"; in "jamcrc %=s %#09.1<jamcrc>";
|
||||
out "adler32 %s %#09.1<adler32>"; in "adler32 %=s %#09.1<adler32>";
|
||||
out "hexsum8 %s %#09.1<hexsum8>"; in "hexsum8 %=s %#09.1<hexsum8>";
|
||||
|
||||
out "sum %s %#-9.1<sum>"; in "sum %=s %#-9.1<sum>";
|
||||
out "sum8 %s %#-9.1<sum8>"; in "sum8 %=s %#-9.1<sum8>";
|
||||
out "sum16 %s %#-9.1<sum16>"; in "sum16 %=s %#-9.1<sum16>";
|
||||
out "sum32 %s %#-9.1<sum32>"; in "sum32 %=s %#-9.1<sum32>";
|
||||
out "nsum %s %#-9.1<nsum>"; in "nsum %=s %#-9.1<nsum>";
|
||||
out "negsum %s %#-9.1<negsum>"; in "negsum %=s %#-9.1<negsum>";
|
||||
out "-sum %s %#-9.1<-sum>"; in "-sum %=s %#-9.1<-sum>";
|
||||
out "nsum8 %s %#-9.1<nsum8>"; in "nsum8 %=s %#-9.1<nsum8>";
|
||||
out "negsum8 %s %#-9.1<negsum8>"; in "negsum8 %=s %#-9.1<negsum8>";
|
||||
out "-sum8 %s %#-9.1<-sum8>"; in "-sum8 %=s %#-9.1<-sum8>";
|
||||
out "nsum16 %s %#-9.1<nsum16>"; in "nsum16 %=s %#-9.1<nsum16>";
|
||||
out "negsum16 %s %#-9.1<negsum1>"; in "negsum16 %=s %#-9.1<negsum1>";
|
||||
out "-sum16 %s %#-9.1<-sum16>"; in "-sum16 %=s %#-9.1<-sum16>";
|
||||
out "nsum32 %s %#-9.1<nsum32>"; in "nsum32 %=s %#-9.1<nsum32>";
|
||||
out "negsum32 %s %#-9.1<negsum3>"; in "negsum32 %=s %#-9.1<negsum3>";
|
||||
out "-sum32 %s %#-9.1<-sum32>"; in "-sum32 %=s %#-9.1<-sum32>";
|
||||
out "notsum %s %#-9.1<notsum>"; in "notsum %=s %#-9.1<notsum>";
|
||||
out "~sum %s %#-9.1<~sum>"; in "~sum %=s %#-9.1<~sum>";
|
||||
out "xor %s %#-9.1<xor>"; in "xor %=s %#-9.1<xor>";
|
||||
out "xor8 %s %#-9.1<xor8>"; in "xor8 %=s %#-9.1<xor8>";
|
||||
out "xor7 %s %#-9.1<xor7>"; in "xor7 %=s %#-9.1<xor7>";
|
||||
out "crc8 %s %#-9.1<crc8>"; in "crc8 %=s %#-9.1<crc8>";
|
||||
out "ccitt8 %s %#-9.1<ccitt8>"; in "ccitt8 %=s %#-9.1<ccitt8>";
|
||||
out "crc16 %s %#-9.1<crc16>"; in "crc16 %=s %#-9.1<crc16>";
|
||||
out "crc16r %s %#-9.1<crc16r>"; in "crc16r %=s %#-9.1<crc16r>";
|
||||
out "ccitt16 %s %#-9.1<ccitt16>"; in "ccitt16 %=s %#-9.1<ccitt16>";
|
||||
out "ccitt16a %s %#-9.1<ccitt16a>"; in "ccitt16a %=s %#-9.1<ccitt16a>";
|
||||
out "ccitt16x %s %#-9.1<ccitt16x>"; in "ccitt16x %=s %#-9.1<ccitt16x>";
|
||||
out "crc16c %s %#-9.1<crc16c>"; in "crc16c %=s %#-9.1<crc16c>";
|
||||
out "xmodem %s %#-9.1<xmodem>"; in "xmodem %=s %#-9.1<xmodem>";
|
||||
out "crc32 %s %#-9.1<crc32>"; in "crc32 %=s %#-9.1<crc32>";
|
||||
out "crc32r %s %#-9.1<crc32r>"; in "crc32r %=s %#-9.1<crc32r>";
|
||||
out "jamcrc %s %#-9.1<jamcrc>"; in "jamcrc %=s %#-9.1<jamcrc>";
|
||||
out "adler32 %s %#-9.1<adler32>"; in "adler32 %=s %#-9.1<adler32>";
|
||||
out "hexsum8 %s %#-9.1<hexsum8>"; in "hexsum8 %=s %#-9.1<hexsum8>";
|
||||
out "DONE";
|
||||
}
|
||||
}
|
||||
|
||||
set startup {
|
||||
@ -24,7 +242,432 @@ set startup {
|
||||
set debug 0
|
||||
|
||||
startioc
|
||||
ioccmd {dbpf DZ:test1 "1"}
|
||||
assure "\x55\x40\x04\x00\x00z;\x4e"
|
||||
|
||||
ioccmd {dbpf DZ:test1 "123456789"}
|
||||
assure "sum 123456789 \xDD\n"
|
||||
send "sum 123456789 \xDD\n"
|
||||
assure "sum8 123456789 \xDD\n"
|
||||
send "sum8 123456789 \xDD\n"
|
||||
assure "sum16 123456789 \x01\xDD\n"
|
||||
send "sum16 123456789 \x01\xDD\n"
|
||||
assure "sum32 123456789 \x00\x00\x01\xDD\n"
|
||||
send "sum32 123456789 \x00\x00\x01\xDD\n"
|
||||
assure "nsum 123456789 \x23\n"
|
||||
send "nsum 123456789 \x23\n"
|
||||
assure "negsum 123456789 \x23\n"
|
||||
send "negsum 123456789 \x23\n"
|
||||
assure "-sum 123456789 \x23\n"
|
||||
send "-sum 123456789 \x23\n"
|
||||
assure "nsum8 123456789 \x23\n"
|
||||
send "nsum8 123456789 \x23\n"
|
||||
assure "negsum8 123456789 \x23\n"
|
||||
send "negsum8 123456789 \x23\n"
|
||||
assure "-sum8 123456789 \x23\n"
|
||||
send "-sum8 123456789 \x23\n"
|
||||
assure "nsum16 123456789 \xFE\x23\n"
|
||||
send "nsum16 123456789 \xFE\x23\n"
|
||||
assure "negsum16 123456789 \xFE\x23\n"
|
||||
send "negsum16 123456789 \xFE\x23\n"
|
||||
assure "-sum16 123456789 \xFE\x23\n"
|
||||
send "-sum16 123456789 \xFE\x23\n"
|
||||
assure "nsum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
send "nsum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
assure "negsum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
send "negsum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
assure "-sum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
send "-sum32 123456789 \xFF\xFF\xFE\x23\n"
|
||||
assure "notsum 123456789 \x22\n"
|
||||
send "notsum 123456789 \x22\n"
|
||||
assure "~sum 123456789 \x22\n"
|
||||
send "~sum 123456789 \x22\n"
|
||||
assure "xor 123456789 \x31\n"
|
||||
send "xor 123456789 \x31\n"
|
||||
assure "xor8 123456789 \x31\n"
|
||||
send "xor8 123456789 \x31\n"
|
||||
assure "xor7 123456789 \x31\n"
|
||||
send "xor7 123456789 \x31\n"
|
||||
assure "crc8 123456789 \xF4\n"
|
||||
send "crc8 123456789 \xF4\n"
|
||||
assure "ccitt8 123456789 \xA1\n"
|
||||
send "ccitt8 123456789 \xA1\n"
|
||||
assure "crc16 123456789 \xFE\xE8\n"
|
||||
send "crc16 123456789 \xFE\xE8\n"
|
||||
assure "crc16r 123456789 \xBB\x3D\n"
|
||||
send "crc16r 123456789 \xBB\x3D\n"
|
||||
assure "ccitt16 123456789 \x29\xB1\n"
|
||||
send "ccitt16 123456789 \x29\xB1\n"
|
||||
assure "ccitt16a 123456789 \xE5\xCC\n"
|
||||
send "ccitt16a 123456789 \xE5\xCC\n"
|
||||
assure "ccitt16x 123456789 \x31\xC3\n"
|
||||
send "ccitt16x 123456789 \x31\xC3\n"
|
||||
assure "crc16c 123456789 \x31\xC3\n"
|
||||
send "crc16c 123456789 \x31\xC3\n"
|
||||
assure "xmodem 123456789 \x31\xC3\n"
|
||||
send "xmodem 123456789 \x31\xC3\n"
|
||||
assure "crc32 123456789 \xFC\x89\x19\x18\n"
|
||||
send "crc32 123456789 \xFC\x89\x19\x18\n"
|
||||
assure "crc32r 123456789 \xCB\xF4\x39\x26\n"
|
||||
send "crc32r 123456789 \xCB\xF4\x39\x26\n"
|
||||
assure "jamcrc 123456789 \x34\x0B\xC6\xD9\n"
|
||||
send "jamcrc 123456789 \x34\x0B\xC6\xD9\n"
|
||||
assure "adler32 123456789 \x09\x1E\x01\xDE\n"
|
||||
send "adler32 123456789 \x09\x1E\x01\xDE\n"
|
||||
assure "hexsum8 123456789 \x2D\n"
|
||||
send "hexsum8 123456789 \x2D\n"
|
||||
|
||||
assure "sum 123456789 DD\n"
|
||||
send "sum 123456789 DD\n"
|
||||
assure "sum8 123456789 DD\n"
|
||||
send "sum8 123456789 DD\n"
|
||||
assure "sum16 123456789 01DD\n"
|
||||
send "sum16 123456789 01DD\n"
|
||||
assure "sum32 123456789 000001DD\n"
|
||||
send "sum32 123456789 000001DD\n"
|
||||
assure "nsum 123456789 23\n"
|
||||
send "nsum 123456789 23\n"
|
||||
assure "negsum 123456789 23\n"
|
||||
send "negsum 123456789 23\n"
|
||||
assure "-sum 123456789 23\n"
|
||||
send "-sum 123456789 23\n"
|
||||
assure "nsum8 123456789 23\n"
|
||||
send "nsum8 123456789 23\n"
|
||||
assure "negsum8 123456789 23\n"
|
||||
send "negsum8 123456789 23\n"
|
||||
assure "-sum8 123456789 23\n"
|
||||
send "-sum8 123456789 23\n"
|
||||
assure "nsum16 123456789 FE23\n"
|
||||
send "nsum16 123456789 FE23\n"
|
||||
assure "negsum16 123456789 FE23\n"
|
||||
send "negsum16 123456789 FE23\n"
|
||||
assure "-sum16 123456789 FE23\n"
|
||||
send "-sum16 123456789 FE23\n"
|
||||
assure "nsum32 123456789 FFFFFE23\n"
|
||||
send "nsum32 123456789 FFFFFE23\n"
|
||||
assure "negsum32 123456789 FFFFFE23\n"
|
||||
send "negsum32 123456789 FFFFFE23\n"
|
||||
assure "-sum32 123456789 FFFFFE23\n"
|
||||
send "-sum32 123456789 FFFFFE23\n"
|
||||
assure "notsum 123456789 22\n"
|
||||
send "notsum 123456789 22\n"
|
||||
assure "~sum 123456789 22\n"
|
||||
send "~sum 123456789 22\n"
|
||||
assure "xor 123456789 31\n"
|
||||
send "xor 123456789 31\n"
|
||||
assure "xor8 123456789 31\n"
|
||||
send "xor8 123456789 31\n"
|
||||
assure "xor7 123456789 31\n"
|
||||
send "xor7 123456789 31\n"
|
||||
assure "crc8 123456789 F4\n"
|
||||
send "crc8 123456789 F4\n"
|
||||
assure "ccitt8 123456789 A1\n"
|
||||
send "ccitt8 123456789 A1\n"
|
||||
assure "crc16 123456789 FEE8\n"
|
||||
send "crc16 123456789 FEE8\n"
|
||||
assure "crc16r 123456789 BB3D\n"
|
||||
send "crc16r 123456789 BB3D\n"
|
||||
assure "ccitt16 123456789 29B1\n"
|
||||
send "ccitt16 123456789 29B1\n"
|
||||
assure "ccitt16a 123456789 E5CC\n"
|
||||
send "ccitt16a 123456789 E5CC\n"
|
||||
assure "ccitt16x 123456789 31C3\n"
|
||||
send "ccitt16x 123456789 31C3\n"
|
||||
assure "crc16c 123456789 31C3\n"
|
||||
send "crc16c 123456789 31C3\n"
|
||||
assure "xmodem 123456789 31C3\n"
|
||||
send "xmodem 123456789 31C3\n"
|
||||
assure "crc32 123456789 FC891918\n"
|
||||
send "crc32 123456789 FC891918\n"
|
||||
assure "crc32r 123456789 CBF43926\n"
|
||||
send "crc32r 123456789 CBF43926\n"
|
||||
assure "jamcrc 123456789 340BC6D9\n"
|
||||
send "jamcrc 123456789 340BC6D9\n"
|
||||
assure "adler32 123456789 091E01DE\n"
|
||||
send "adler32 123456789 091E01DE\n"
|
||||
assure "hexsum8 123456789 2D\n"
|
||||
send "hexsum8 123456789 2D\n"
|
||||
|
||||
assure "sum 123456789 \x3D\x3D\n"
|
||||
send "sum 123456789 \x3D\x3D\n"
|
||||
assure "sum8 123456789 \x3D\x3D\n"
|
||||
send "sum8 123456789 \x3D\x3D\n"
|
||||
assure "sum16 123456789 \x30\x31\x3D\x3D\n"
|
||||
send "sum16 123456789 \x30\x31\x3D\x3D\n"
|
||||
assure "sum32 123456789 \x30\x30\x30\x30\x30\x31\x3D\x3D\n"
|
||||
send "sum32 123456789 \x30\x30\x30\x30\x30\x31\x3D\x3D\n"
|
||||
assure "nsum 123456789 \x32\x33\n"
|
||||
send "nsum 123456789 \x32\x33\n"
|
||||
assure "negsum 123456789 \x32\x33\n"
|
||||
send "negsum 123456789 \x32\x33\n"
|
||||
assure "-sum 123456789 \x32\x33\n"
|
||||
send "-sum 123456789 \x32\x33\n"
|
||||
assure "nsum8 123456789 \x32\x33\n"
|
||||
send "nsum8 123456789 \x32\x33\n"
|
||||
assure "negsum8 123456789 \x32\x33\n"
|
||||
send "negsum8 123456789 \x32\x33\n"
|
||||
assure "-sum8 123456789 \x32\x33\n"
|
||||
send "-sum8 123456789 \x32\x33\n"
|
||||
assure "nsum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
send "nsum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
assure "negsum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
send "negsum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
assure "-sum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
send "-sum16 123456789 \x3F\x3E\x32\x33\n"
|
||||
assure "nsum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
send "nsum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
assure "negsum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
send "negsum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
assure "-sum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
send "-sum32 123456789 \x3F\x3F\x3F\x3F\x3F\x3E\x32\x33\n"
|
||||
assure "notsum 123456789 \x32\x32\n"
|
||||
send "notsum 123456789 \x32\x32\n"
|
||||
assure "~sum 123456789 \x32\x32\n"
|
||||
send "~sum 123456789 \x32\x32\n"
|
||||
assure "xor 123456789 \x33\x31\n"
|
||||
send "xor 123456789 \x33\x31\n"
|
||||
assure "xor8 123456789 \x33\x31\n"
|
||||
send "xor8 123456789 \x33\x31\n"
|
||||
assure "xor7 123456789 \x33\x31\n"
|
||||
send "xor7 123456789 \x33\x31\n"
|
||||
assure "crc8 123456789 \x3F\x34\n"
|
||||
send "crc8 123456789 \x3F\x34\n"
|
||||
assure "ccitt8 123456789 \x3A\x31\n"
|
||||
send "ccitt8 123456789 \x3A\x31\n"
|
||||
assure "crc16 123456789 \x3F\x3E\x3E\x38\n"
|
||||
send "crc16 123456789 \x3F\x3E\x3E\x38\n"
|
||||
assure "crc16r 123456789 \x3B\x3B\x33\x3D\n"
|
||||
send "crc16r 123456789 \x3B\x3B\x33\x3D\n"
|
||||
assure "ccitt16 123456789 \x32\x39\x3B\x31\n"
|
||||
send "ccitt16 123456789 \x32\x39\x3B\x31\n"
|
||||
assure "ccitt16a 123456789 \x3E\x35\x3C\x3C\n"
|
||||
send "ccitt16a 123456789 \x3E\x35\x3C\x3C\n"
|
||||
assure "ccitt16x 123456789 \x33\x31\x3C\x33\n"
|
||||
send "ccitt16x 123456789 \x33\x31\x3C\x33\n"
|
||||
assure "crc16c 123456789 \x33\x31\x3C\x33\n"
|
||||
send "crc16c 123456789 \x33\x31\x3C\x33\n"
|
||||
assure "xmodem 123456789 \x33\x31\x3C\x33\n"
|
||||
send "xmodem 123456789 \x33\x31\x3C\x33\n"
|
||||
assure "crc32 123456789 \x3F\x3C\x38\x39\x31\x39\x31\x38\n"
|
||||
send "crc32 123456789 \x3F\x3C\x38\x39\x31\x39\x31\x38\n"
|
||||
assure "crc32r 123456789 \x3C\x3B\x3F\x34\x33\x39\x32\x36\n"
|
||||
send "crc32r 123456789 \x3C\x3B\x3F\x34\x33\x39\x32\x36\n"
|
||||
assure "jamcrc 123456789 \x33\x34\x30\x3B\x3C\x36\x3D\x39\n"
|
||||
send "jamcrc 123456789 \x33\x34\x30\x3B\x3C\x36\x3D\x39\n"
|
||||
assure "adler32 123456789 \x30\x39\x31\x3E\x30\x31\x3D\x3E\n"
|
||||
send "adler32 123456789 \x30\x39\x31\x3E\x30\x31\x3D\x3E\n"
|
||||
assure "hexsum8 123456789 \x32\x3D\n"
|
||||
send "hexsum8 123456789 \x32\x3D\n"
|
||||
|
||||
assure "sum 123456789 \xDD\n"
|
||||
send "sum 123456789 \xDD\n"
|
||||
assure "sum8 123456789 \xDD\n"
|
||||
send "sum8 123456789 \xDD\n"
|
||||
assure "sum16 123456789 \xDD\x01\n"
|
||||
send "sum16 123456789 \xDD\x01\n"
|
||||
assure "sum32 123456789 \xDD\x01\x00\x00\n"
|
||||
send "sum32 123456789 \xDD\x01\x00\x00\n"
|
||||
assure "nsum 123456789 \x23\n"
|
||||
send "nsum 123456789 \x23\n"
|
||||
assure "negsum 123456789 \x23\n"
|
||||
send "negsum 123456789 \x23\n"
|
||||
assure "-sum 123456789 \x23\n"
|
||||
send "-sum 123456789 \x23\n"
|
||||
assure "nsum8 123456789 \x23\n"
|
||||
send "nsum8 123456789 \x23\n"
|
||||
assure "negsum8 123456789 \x23\n"
|
||||
send "negsum8 123456789 \x23\n"
|
||||
assure "-sum8 123456789 \x23\n"
|
||||
send "-sum8 123456789 \x23\n"
|
||||
assure "nsum16 123456789 \x23\xFE\n"
|
||||
send "nsum16 123456789 \x23\xFE\n"
|
||||
assure "negsum16 123456789 \x23\xFE\n"
|
||||
send "negsum16 123456789 \x23\xFE\n"
|
||||
assure "-sum16 123456789 \x23\xFE\n"
|
||||
send "-sum16 123456789 \x23\xFE\n"
|
||||
assure "nsum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
send "nsum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
assure "negsum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
send "negsum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
assure "-sum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
send "-sum32 123456789 \x23\xFE\xFF\xFF\n"
|
||||
assure "notsum 123456789 \x22\n"
|
||||
send "notsum 123456789 \x22\n"
|
||||
assure "~sum 123456789 \x22\n"
|
||||
send "~sum 123456789 \x22\n"
|
||||
assure "xor 123456789 \x31\n"
|
||||
send "xor 123456789 \x31\n"
|
||||
assure "xor8 123456789 \x31\n"
|
||||
send "xor8 123456789 \x31\n"
|
||||
assure "xor7 123456789 \x31\n"
|
||||
send "xor7 123456789 \x31\n"
|
||||
assure "crc8 123456789 \xF4\n"
|
||||
send "crc8 123456789 \xF4\n"
|
||||
assure "ccitt8 123456789 \xA1\n"
|
||||
send "ccitt8 123456789 \xA1\n"
|
||||
assure "crc16 123456789 \xE8\xFE\n"
|
||||
send "crc16 123456789 \xE8\xFE\n"
|
||||
assure "crc16r 123456789 \x3D\xBB\n"
|
||||
send "crc16r 123456789 \x3D\xBB\n"
|
||||
assure "ccitt16 123456789 \xB1\x29\n"
|
||||
send "ccitt16 123456789 \xB1\x29\n"
|
||||
assure "ccitt16a 123456789 \xCC\xE5\n"
|
||||
send "ccitt16a 123456789 \xCC\xE5\n"
|
||||
assure "ccitt16x 123456789 \xC3\x31\n"
|
||||
send "ccitt16x 123456789 \xC3\x31\n"
|
||||
assure "crc16c 123456789 \xC3\x31\n"
|
||||
send "crc16c 123456789 \xC3\x31\n"
|
||||
assure "xmodem 123456789 \xC3\x31\n"
|
||||
send "xmodem 123456789 \xC3\x31\n"
|
||||
assure "crc32 123456789 \x18\x19\x89\xFC\n"
|
||||
send "crc32 123456789 \x18\x19\x89\xFC\n"
|
||||
assure "crc32r 123456789 \x26\x39\xF4\xCB\n"
|
||||
send "crc32r 123456789 \x26\x39\xF4\xCB\n"
|
||||
assure "jamcrc 123456789 \xD9\xC6\x0B\x34\n"
|
||||
send "jamcrc 123456789 \xD9\xC6\x0B\x34\n"
|
||||
assure "adler32 123456789 \xDE\x01\x1E\x09\n"
|
||||
send "adler32 123456789 \xDE\x01\x1E\x09\n"
|
||||
assure "hexsum8 123456789 \x2D\n"
|
||||
send "hexsum8 123456789 \x2D\n"
|
||||
|
||||
assure "sum 123456789 DD\n"
|
||||
send "sum 123456789 DD\n"
|
||||
assure "sum8 123456789 DD\n"
|
||||
send "sum8 123456789 DD\n"
|
||||
assure "sum16 123456789 DD01\n"
|
||||
send "sum16 123456789 DD01\n"
|
||||
assure "sum32 123456789 DD010000\n"
|
||||
send "sum32 123456789 DD010000\n"
|
||||
assure "nsum 123456789 23\n"
|
||||
send "nsum 123456789 23\n"
|
||||
assure "negsum 123456789 23\n"
|
||||
send "negsum 123456789 23\n"
|
||||
assure "-sum 123456789 23\n"
|
||||
send "-sum 123456789 23\n"
|
||||
assure "nsum8 123456789 23\n"
|
||||
send "nsum8 123456789 23\n"
|
||||
assure "negsum8 123456789 23\n"
|
||||
send "negsum8 123456789 23\n"
|
||||
assure "-sum8 123456789 23\n"
|
||||
send "-sum8 123456789 23\n"
|
||||
assure "nsum16 123456789 23FE\n"
|
||||
send "nsum16 123456789 23FE\n"
|
||||
assure "negsum16 123456789 23FE\n"
|
||||
send "negsum16 123456789 23FE\n"
|
||||
assure "-sum16 123456789 23FE\n"
|
||||
send "-sum16 123456789 23FE\n"
|
||||
assure "nsum32 123456789 23FEFFFF\n"
|
||||
send "nsum32 123456789 23FEFFFF\n"
|
||||
assure "negsum32 123456789 23FEFFFF\n"
|
||||
send "negsum32 123456789 23FEFFFF\n"
|
||||
assure "-sum32 123456789 23FEFFFF\n"
|
||||
send "-sum32 123456789 23FEFFFF\n"
|
||||
assure "notsum 123456789 22\n"
|
||||
send "notsum 123456789 22\n"
|
||||
assure "~sum 123456789 22\n"
|
||||
send "~sum 123456789 22\n"
|
||||
assure "xor 123456789 31\n"
|
||||
send "xor 123456789 31\n"
|
||||
assure "xor8 123456789 31\n"
|
||||
send "xor8 123456789 31\n"
|
||||
assure "xor7 123456789 31\n"
|
||||
send "xor7 123456789 31\n"
|
||||
assure "crc8 123456789 F4\n"
|
||||
send "crc8 123456789 F4\n"
|
||||
assure "ccitt8 123456789 A1\n"
|
||||
send "ccitt8 123456789 A1\n"
|
||||
assure "crc16 123456789 E8FE\n"
|
||||
send "crc16 123456789 E8FE\n"
|
||||
assure "crc16r 123456789 3DBB\n"
|
||||
send "crc16r 123456789 3DBB\n"
|
||||
assure "ccitt16 123456789 B129\n"
|
||||
send "ccitt16 123456789 B129\n"
|
||||
assure "ccitt16a 123456789 CCE5\n"
|
||||
send "ccitt16a 123456789 CCE5\n"
|
||||
assure "ccitt16x 123456789 C331\n"
|
||||
send "ccitt16x 123456789 C331\n"
|
||||
assure "crc16c 123456789 C331\n"
|
||||
send "crc16c 123456789 C331\n"
|
||||
assure "xmodem 123456789 C331\n"
|
||||
send "xmodem 123456789 C331\n"
|
||||
assure "crc32 123456789 181989FC\n"
|
||||
send "crc32 123456789 181989FC\n"
|
||||
assure "crc32r 123456789 2639F4CB\n"
|
||||
send "crc32r 123456789 2639F4CB\n"
|
||||
assure "jamcrc 123456789 D9C60B34\n"
|
||||
send "jamcrc 123456789 D9C60B34\n"
|
||||
assure "adler32 123456789 DE011E09\n"
|
||||
send "adler32 123456789 DE011E09\n"
|
||||
assure "hexsum8 123456789 2D\n"
|
||||
send "hexsum8 123456789 2D\n"
|
||||
|
||||
assure "sum 123456789 \x3D\x3D\n"
|
||||
send "sum 123456789 \x3D\x3D\n"
|
||||
assure "sum8 123456789 \x3D\x3D\n"
|
||||
send "sum8 123456789 \x3D\x3D\n"
|
||||
assure "sum16 123456789 \x3D\x3D\x30\x31\n"
|
||||
send "sum16 123456789 \x3D\x3D\x30\x31\n"
|
||||
assure "sum32 123456789 \x3D\x3D\x30\x31\x30\x30\x30\x30\n"
|
||||
send "sum32 123456789 \x3D\x3D\x30\x31\x30\x30\x30\x30\n"
|
||||
assure "nsum 123456789 \x32\x33\n"
|
||||
send "nsum 123456789 \x32\x33\n"
|
||||
assure "negsum 123456789 \x32\x33\n"
|
||||
send "negsum 123456789 \x32\x33\n"
|
||||
assure "-sum 123456789 \x32\x33\n"
|
||||
send "-sum 123456789 \x32\x33\n"
|
||||
assure "nsum8 123456789 \x32\x33\n"
|
||||
send "nsum8 123456789 \x32\x33\n"
|
||||
assure "negsum8 123456789 \x32\x33\n"
|
||||
send "negsum8 123456789 \x32\x33\n"
|
||||
assure "-sum8 123456789 \x32\x33\n"
|
||||
send "-sum8 123456789 \x32\x33\n"
|
||||
assure "nsum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
send "nsum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
assure "negsum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
send "negsum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
assure "-sum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
send "-sum16 123456789 \x32\x33\x3F\x3E\n"
|
||||
assure "nsum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
send "nsum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
assure "negsum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
send "negsum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
assure "-sum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
send "-sum32 123456789 \x32\x33\x3F\x3E\x3F\x3F\x3F\x3F\n"
|
||||
assure "notsum 123456789 \x32\x32\n"
|
||||
send "notsum 123456789 \x32\x32\n"
|
||||
assure "~sum 123456789 \x32\x32\n"
|
||||
send "~sum 123456789 \x32\x32\n"
|
||||
assure "xor 123456789 \x33\x31\n"
|
||||
send "xor 123456789 \x33\x31\n"
|
||||
assure "xor8 123456789 \x33\x31\n"
|
||||
send "xor8 123456789 \x33\x31\n"
|
||||
assure "xor7 123456789 \x33\x31\n"
|
||||
send "xor7 123456789 \x33\x31\n"
|
||||
assure "crc8 123456789 \x3F\x34\n"
|
||||
send "crc8 123456789 \x3F\x34\n"
|
||||
assure "ccitt8 123456789 \x3A\x31\n"
|
||||
send "ccitt8 123456789 \x3A\x31\n"
|
||||
assure "crc16 123456789 \x3E\x38\x3F\x3E\n"
|
||||
send "crc16 123456789 \x3E\x38\x3F\x3E\n"
|
||||
assure "crc16r 123456789 \x33\x3D\x3B\x3B\n"
|
||||
send "crc16r 123456789 \x33\x3D\x3B\x3B\n"
|
||||
assure "ccitt16 123456789 \x3B\x31\x32\x39\n"
|
||||
send "ccitt16 123456789 \x3B\x31\x32\x39\n"
|
||||
assure "ccitt16a 123456789 \x3C\x3C\x3E\x35\n"
|
||||
send "ccitt16a 123456789 \x3C\x3C\x3E\x35\n"
|
||||
assure "ccitt16x 123456789 \x3C\x33\x33\x31\n"
|
||||
send "ccitt16x 123456789 \x3C\x33\x33\x31\n"
|
||||
assure "crc16c 123456789 \x3C\x33\x33\x31\n"
|
||||
send "crc16c 123456789 \x3C\x33\x33\x31\n"
|
||||
assure "xmodem 123456789 \x3C\x33\x33\x31\n"
|
||||
send "xmodem 123456789 \x3C\x33\x33\x31\n"
|
||||
assure "crc32 123456789 \x31\x38\x31\x39\x38\x39\x3F\x3C\n"
|
||||
send "crc32 123456789 \x31\x38\x31\x39\x38\x39\x3F\x3C\n"
|
||||
assure "crc32r 123456789 \x32\x36\x33\x39\x3F\x34\x3C\x3B\n"
|
||||
send "crc32r 123456789 \x32\x36\x33\x39\x3F\x34\x3C\x3B\n"
|
||||
assure "jamcrc 123456789 \x3D\x39\x3C\x36\x30\x3B\x33\x34\n"
|
||||
send "jamcrc 123456789 \x3D\x39\x3C\x36\x30\x3B\x33\x34\n"
|
||||
assure "adler32 123456789 \x3D\x3E\x30\x31\x31\x3E\x30\x39\n"
|
||||
send "adler32 123456789 \x3D\x3E\x30\x31\x31\x3E\x30\x39\n"
|
||||
assure "hexsum8 123456789 \x32\x3D\n"
|
||||
send "hexsum8 123456789 \x32\x3D\n"
|
||||
assure "DONE\n"
|
||||
|
||||
finish
|
||||
|
||||
@ -30,11 +30,6 @@ set records {
|
||||
field (DTYP, "stream")
|
||||
field (OUT, "@test.proto bcd device")
|
||||
}
|
||||
record (stringout, "DZ:chksum")
|
||||
{
|
||||
field (DTYP, "stream")
|
||||
field (OUT, "@test.proto chksum device")
|
||||
}
|
||||
}
|
||||
|
||||
set protocol {
|
||||
@ -43,13 +38,6 @@ set protocol {
|
||||
ao {out "%.2f %.2e %.2E %.2g %.2G %i %d %u %o %04x %#.2f %#.2e %#.2E %#.2g %#.2G %#i %#d %#u %#o %#06x";}
|
||||
lo {out "%d %(VAL)d %06d %x %06X %b %06b %.6b %B.! %06B.!";}
|
||||
bcd {out "%D %6D %.2D %.4D %.6D %.8D %#D %#6D %#.2D %#.4D %#.6D";}
|
||||
chksum {out "%s%<xor>";
|
||||
out "%s%0<sum>";
|
||||
out "%s%0<crc8>";
|
||||
out "%s%0<crc16>";
|
||||
out "%s%0<crc32>";
|
||||
out "%s%0<adler32>";
|
||||
}
|
||||
}
|
||||
|
||||
set startup {
|
||||
@ -100,11 +88,4 @@ assure "\0\0\0\0\1\2\3\4 \0\0\0\0\1\2\3\4 \4 \3\4 \2\3\4 \1\2\3\4 \4\3\2\1\0\0\0
|
||||
} else {
|
||||
assure "\1\2\3\4 \0\0\1\2\3\4 \4 \3\4 \2\3\4 \1\2\3\4 \4\3\2\1 \4\3\2\1\0\0 \4 \4\3 \4\3\2\n"
|
||||
}
|
||||
ioccmd {dbpf DZ:chksum "123456789"}
|
||||
assure "1234567891\n"
|
||||
assure "123456789DD\n"
|
||||
assure "123456789F4\n"
|
||||
assure "123456789FEE8\n"
|
||||
assure "123456789FC891918\n"
|
||||
assure "123456789091E01DE\n"
|
||||
finish
|
||||
|
||||
33
streamApp/tests/testStrangesum
Executable file
33
streamApp/tests/testStrangesum
Executable file
@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env tclsh
|
||||
source streamtestlib.tcl
|
||||
|
||||
# Define records, protocol and startup (text goes to files)
|
||||
# The asynPort "device" is connected to a network TCP socket
|
||||
# Talk to the socket with send/receive/assure
|
||||
# Send commands to the ioc shell with ioccmd
|
||||
|
||||
set records {
|
||||
record (stringout, "DZ:test1")
|
||||
{
|
||||
field (DTYP, "stream")
|
||||
field (OUT, "@test.proto test1 device")
|
||||
}
|
||||
}
|
||||
|
||||
set protocol {
|
||||
Terminator="\r\n";
|
||||
test1 {
|
||||
out ":%s%01<-hexsum8>";
|
||||
}
|
||||
}
|
||||
|
||||
set startup {
|
||||
}
|
||||
|
||||
set debug 0
|
||||
|
||||
startioc
|
||||
ioccmd {dbpf DZ:test1 "010304010001"}
|
||||
assure ":010304010001F6\r\n"
|
||||
|
||||
finish
|
||||
Reference in New Issue
Block a user