/// Save the ANN to a C file handle.
int SaveANN(ANN* ann, FILE* f)
{
if (f==NULL) {
return -1;
}
StringBuffer* rtag = NewStringBuffer (256);
WriteToken("VSOUND_ANN", f);
fwrite(&ann->n_inputs, sizeof(int), 1, f);
fwrite(&ann->n_outputs, sizeof(int), 1, f);
WriteToken("Layer Data", f);
int n_layers = 0;
LISTITEM* list_item = FirstListItem(ann->c);
while (list_item) {
n_layers++;
list_item = NextListItem (ann->c);
}
fwrite(&n_layers, sizeof(int), 1, f);
list_item = FirstListItem(ann->c);
for (int i=0; i<n_layers-1; i++) {
Layer* l = (Layer*) list_item->obj;
int layer_type = 0;
WriteToken("TYPE", f);
fwrite(&layer_type, sizeof(int), 1, f);
int nhu = l->n_outputs;
WriteToken("UNITS", f);
fwrite(&nhu, sizeof(int), 1, f);
list_item = NextListItem (ann->c);
}
WriteToken("Output Type", f);
{
int layer_type = 0;
LISTITEM *c;
c = LastListItem(ann->c);
if (c) {
Layer *l = (Layer *) c->obj;
if (l->f==&linear) {
layer_type = 0;
} else {
layer_type = 1;
}
}
fwrite(&layer_type, sizeof(int), 1, f);
}
list_item = FirstListItem(ann->c);
while(list_item) {
Layer* l = (Layer*) list_item->obj;
WriteToken("Connections", f);
int size = (l->n_inputs + 1 /*bias*/) * l->n_outputs;
fwrite(l->c, size, sizeof(Connection), f);
list_item = NextListItem(ann->c);
}
WriteToken("END", f);
FreeStringBuffer (&rtag);
return 0;
}
int WriteEncryptedToken (int inSocket,
const gss_ctx_id_t inContext,
const char *inToken,
size_t inTokenLength)
{
int err = 0;
OM_uint32 majorStatus;
OM_uint32 minorStatus = 0;
gss_buffer_desc outputBuffer = { 0, NULL };
if (!inContext) { err = EINVAL; }
if (!inToken ) { err = EINVAL; }
if (!err) {
gss_buffer_desc inputBuffer = { inTokenLength, (char *) inToken };
int encrypt = 1; /* do encryption and integrity protection */
int encrypted = 0; /* did mechanism encrypt/integrity protect? */
majorStatus = gss_wrap (&minorStatus,
inContext,
encrypt,
GSS_C_QOP_DEFAULT,
&inputBuffer,
&encrypted,
&outputBuffer);
if (majorStatus != GSS_S_COMPLETE) {
printGSSErrors ("gss_wrap", majorStatus, minorStatus);
err = minorStatus ? minorStatus : majorStatus;
} else if (!encrypted) {
fprintf (stderr, "WARNING! Mechanism does not support encryption!");
err = EAUTH; /* You may not want to fail here. */
}
}
if (!err) {
printf ("Unencrypted token:\n");
PrintBuffer (inToken, inTokenLength);
err = WriteToken (inSocket, outputBuffer.value, outputBuffer.length);
}
if (!err) {
} else {
printError (err, "WriteToken failed");
}
if (outputBuffer.value) { gss_release_buffer (&minorStatus, &outputBuffer); }
return err;
}
void InfixPrinter::Print(
const LispPtr& aExpression,
std::ostream& aOutput,
LispInt iPrecedence)
{
assert(aExpression);
const LispString* string = aExpression->String();
if (string) {
LispInt bracket = 0;
if (iPrecedence < KMaxPrecedence &&
(*string)[0] == '-' &&
(std::isdigit((*string)[1]) || (*string)[1] == '.')
) {
bracket = 1;
}
if (bracket) WriteToken(aOutput, "(");
WriteToken(aOutput, *string);
if (bracket) WriteToken(aOutput, ")");
return;
}
if (const GenericClass* g = aExpression->Generic()) {
if (const AssociationClass* a = dynamic_cast<const AssociationClass*>(g)) {
WriteToken(aOutput, "Association");
WriteToken(aOutput, "(");
Print(a->ToList(), aOutput, KMaxPrecedence);
WriteToken(aOutput, ")");
} else if (const ArrayClass* a = dynamic_cast<const ArrayClass*>(g)) {
WriteToken(aOutput, "Array");
WriteToken(aOutput, "(");
WriteToken(aOutput, "{");
const std::size_t n = a->Size();
for (std::size_t i = 1; i <= n; ++i) {
Print(LispPtr(a->GetElement(i)), aOutput, KMaxPrecedence);
if (i != n)
WriteToken(aOutput, ",");
}
WriteToken(aOutput, "}");
WriteToken(aOutput, ")");
} else {
WriteToken(aOutput, g->TypeName());
}
return;
}
LispPtr* subList = aExpression->SubList();
if (!subList) {
throw LispErrUnprintableToken();
} else {
LispInt length = InternalListLength(*subList);
string = (*subList)->String();
const LispOperators::const_iterator prefix =
length != 2
? iPrefixOperators.end()
: iPrefixOperators.find(string);
const LispOperators::const_iterator infix =
length != 3
? iInfixOperators.end()
: iInfixOperators.find(string);
const LispOperators::const_iterator postfix =
length != 2
? iPostfixOperators.end()
: iPostfixOperators.find(string);
const LispOperators::const_iterator bodied =
iBodiedOperators.find(string);
const LispInFixOperator* op = nullptr;
if (prefix != iPrefixOperators.end())
op = &prefix->second;
if (postfix != iPostfixOperators.end())
op = &postfix->second;
if (infix != iInfixOperators.end())
op = &infix->second;
if (op) {
LispPtr* left = nullptr;
LispPtr* right = nullptr;
if (prefix != iPrefixOperators.end()) {
right = &(*subList)->Nixed();
} else if (infix != iInfixOperators.end()) {
left = &(*subList)->Nixed();
right = &(*subList)->Nixed()->Nixed();
} else if (postfix != iPostfixOperators.end()) {
left = &(*subList)->Nixed();
}
if (iPrecedence < op->iPrecedence) {
WriteToken(aOutput, "(");
} else {
//Vladimir? aOutput.Write(" ");
}
if (left)
Print(*left, aOutput, op->iLeftPrecedence);
WriteToken(aOutput, *string);
if (right)
Print(*right, aOutput, op->iRightPrecedence);
if (iPrecedence < op->iPrecedence)
WriteToken(aOutput, ")");
} else {
LispIterator iter((*subList)->Nixed());
if (string == iCurrentEnvironment->iList->String()) {
WriteToken(aOutput, "{");
for (int ii = 0; iter.getObj(); ii++, ++iter) {
if (ii) WriteToken(aOutput, ",");
Print(*iter, aOutput, KMaxPrecedence);
}
WriteToken(aOutput, "}");
} else if (string == iCurrentEnvironment->iProg->String()) {
WriteToken(aOutput, "[");
while (iter.getObj()) {
Print(*iter, aOutput, KMaxPrecedence);
++iter;
WriteToken(aOutput, ";");
}
WriteToken(aOutput, "]");
} else if (string == iCurrentEnvironment->iNth->String()) {
Print(*iter, aOutput, 0);
++iter;
WriteToken(aOutput, "[");
Print(*iter, aOutput, KMaxPrecedence);
WriteToken(aOutput, "]");
} else {
LispInt bracket = false;
if (bodied != iBodiedOperators.end()) {
//printf("%d > %d\n",iPrecedence, bodied->iPrecedence);
if (iPrecedence < bodied->second.iPrecedence)
bracket = true;
}
if (bracket) WriteToken(aOutput, "(");
if (string) {
WriteToken(aOutput, *string);
} else {
Print(*subList, aOutput, 0);
}
WriteToken(aOutput, "(");
LispIterator counter(*iter);
LispInt nr = 0;
while (counter.getObj()) {
++counter;
nr++;
}
if (bodied != iBodiedOperators.end())
nr--;
while (nr--) {
Print(*iter, aOutput, KMaxPrecedence);
++iter;
if (nr)
WriteToken(aOutput, ",");
}
WriteToken(aOutput, ")");
if (iter.getObj()) {
assert(bodied != iBodiedOperators.end());
Print(*iter, aOutput, bodied->second.iPrecedence);
}
if (bracket)
WriteToken(aOutput, ")");
}
}
}
}
/*********************************************************************
* Function: FormatManPage
*
* FormatManPage is the top entry point for formating man pages
* into a form understood by a display area.
*
*********************************************************************/
static int
FormatManPage(
VarHandle my_vars,
BufFilePtr in_file,
char *in_buf,
int in_size,
_DtHelpFontHints *font_attr,
char **out_buf,
int *out_size,
int *out_max )
{
int italicCnt = 0;
int result = 0;
int cread;
int lastLen;
int checkLen;
int retWCLen;
wchar_t lastWC;
wchar_t retWC;
char *rloc = in_buf;
char *retStrPtr;
char c;
char retC;
Boolean flag = False;
enum State newState;
enum State state = Char;
cread = strlen (rloc);
do
{
/*
* while I can read information process; loop.
*/
while (result != -1 && cread > 0)
{
/**
* check for the size of the character
**/
checkLen = mblen(rloc, MB_CUR_MAX);
/*
* if we hit a null character before we've run out of characters,
* we've got corrupt data.
*/
if (checkLen == 0)
return -1;
if (checkLen > 0)
{
/*
* check for end of line
*/
if (checkLen == 1 && *rloc == '\n')
{
cread--;
if (state == Bold || state == Italic)
result = WriteToken(EndToken, EndTokenSize,
out_buf, out_size, out_max);
if (result != -1)
result = _DtHelpCeAddCharToBuf (&rloc, out_buf,
out_size, out_max, 128);
if (result != -1)
{
result = __DtHelpCeProcessString(
my_vars, NULL,
_DtCvLITERAL,
ScanString,
*out_buf,
*out_size,
0,
False,
font_attr);
*out_size = 0;
(*out_buf)[0] = '\0';
state = Char;
}
}
else
{
switch (state)
{
case Char:
case BoldDone:
case BoldItalicDone:
/*
* get the character and wide character
* representation of the next character.
*/
c = *rloc;
lastLen = mbtowc (&lastWC, rloc, MB_CUR_MAX);
/*
* skip past this character.
*/
rloc = rloc + lastLen;
cread = cread - lastLen;
/*
* Check ahead for bold or italic sequences
*/
newState = GetNextState (c, lastWC, lastLen,
rloc,
&retC, &retWC, &retWCLen,
&retStrPtr, &flag);
if (newState == Bold)
{
if (state == BoldDone)
RemoveToken(EndTokenSize, out_buf, out_size);
else
result = WriteToken(BoldToken,
BoldTokenSize,
out_buf, out_size,
out_max);
/*
* skip the backspaces and the extra
* copy of the character.
*/
cread = cread - (retStrPtr - rloc);
rloc = retStrPtr;
}
else if (newState == Italic)
{
if (state != BoldItalicDone)
result = WriteToken(ItalicToken,
ItalicTokenSize,
out_buf, out_size,
out_max);
/*
* skip the blanks after the current
* character plus the character after
* that. The returned wide character
* is the character that is to be
* italicized.
*/
cread = cread - (retStrPtr - rloc);
rloc = retStrPtr;
c = retC;
lastWC = retWC;
lastLen = retWCLen;
italicCnt = 1;
if (state == BoldItalicDone &&
GetNextState (c, lastWC, lastLen, rloc,
&retC, &retWC, &retWCLen,
&retStrPtr, &flag) == Bold)
{
RemoveToken(EndTokenSize, out_buf, out_size);
newState = BoldItalic;
}
}
else if (state == BoldItalicDone)
result = WriteToken(EndToken, EndTokenSize,
out_buf, out_size,
out_max);
state = newState;
result = WriteOutChar(lastLen, lastWC, c,
out_buf, out_size, out_max, flag);
break;
case BoldItalic:
case Bold:
if (GetNextState (c, lastWC, lastLen, rloc,
&retC, &retWC, &retWCLen,
&retStrPtr, &flag) == Bold)
{
/* skip backspaces and copy characters */
cread = cread - (retStrPtr - rloc);
rloc = retStrPtr;
}
else
{
result = WriteToken(EndToken, EndTokenSize,
out_buf, out_size, out_max);
if (state == BoldItalic)
state = BoldItalicDone;
else
state = BoldDone;
}
break;
case Italic:
c = *rloc;
newState = GetNextState (c, lastWC, lastLen,
rloc,
&retC, &retWC, &retWCLen,
&retStrPtr, &flag);
if (newState == Italic)
{
italicCnt++;
cread = cread - (retStrPtr - rloc);
rloc = retStrPtr;
c = retC;
lastWC = retWC;
lastLen = retWCLen;
result = WriteOutChar(lastLen, lastWC, c,
out_buf, out_size, out_max, flag);
}
else if (italicCnt == 1 && lastWC == retWC
&& newState == Bold)
{
RemoveToken(lastLen, out_buf, out_size);
result = WriteToken(BoldToken,
BoldTokenSize,
out_buf, out_size,
out_max);
cread = cread - (retStrPtr - rloc);
rloc = retStrPtr;
c = retC;
lastWC = retWC;
lastLen = retWCLen;
result = WriteOutChar(lastLen, lastWC, c,
out_buf, out_size, out_max, flag);
state = BoldItalic;
}
else
{
result = WriteToken(EndToken,
EndTokenSize,
out_buf, out_size,
out_max);
state = Char;
italicCnt = 0;
}
break;
}
}
if (cread < (3 * ((int) MB_CUR_MAX)) &&
!feof (FileStream(in_file)))
cread = 0;
}
else
{
/**
* if it is an invalid character - skip.
* But be careful.
* If this is the start of a multi-byte character,
* I must save it and try again on the next read.
**/
if (cread < ((int) MB_CUR_MAX))
cread = 0;
else
{
/*
* otherwise we've got corrupt data.
*/
return -1;
}
}
}
if (result != -1 && !feof(FileStream(in_file)))
{
if (_DtHelpCeGetNxtBuf (in_file, in_buf, &rloc, in_size) == -1)
result = -1;
if (result != -1)
cread = strlen (rloc);
}
} while (result != -1 && cread > 0);
return(result);
} /* End FormatManPage */
