/*****************************************************************************
*
* Boolean AsnBinBufWrite(aip, atp, buf, buflen)
*
*****************************************************************************/
NLM_EXTERN Boolean LIBCALL AsnBinBufWrite (AsnIoPtr aip, AsnTypePtr atp, CharPtr buf, size_t buflen)
{
int isa;
AsnTypePtr atp2;
int next_type;
if (! AsnTypeValidateOut(aip, atp, NULL))
return FALSE;
atp2 = AsnFindBaseType(atp);
isa = atp2->type->isa;
if (ISA_STRINGTYPE(isa))
isa = GENERALSTRING_TYPE;
AsnEnBinTags(atp, aip); /* put in the tags */
switch (isa) {
case GENERALSTRING_TYPE:
case OCTETS_TYPE:
case STRSTORE_TYPE:
AsnEnBinBuf(buf, buflen, aip, atp);
break;
default:
AsnIoErrorMsg(aip, 19, AsnErrGetTypeName(atp->name));
return FALSE;
}
if (atp->tagclass != TAG_NONE)
AsnEnBinEndIndef(aip); /* put indefinite encoding */
next_type = aip->type_indent - 1; /* end any choices */
while ((next_type >= 0) &&
(AsnFindBaseIsa(aip->typestack[next_type].type) == CHOICE_TYPE)) {
if (aip->typestack[next_type].type->tagclass != TAG_NONE)
AsnEnBinEndIndef(aip);
next_type--;
}
if (AsnFindBaseIsa(aip->typestack[aip->type_indent - 1].type) == CHOICE_TYPE)
AsnTypeSetIndent(FALSE, aip, atp);
return TRUE;
}
/*****************************************************************************
*
* Boolean AsnBinWrite(aip, atp, valueptr)
*
*****************************************************************************/
NLM_EXTERN Boolean LIBCALL AsnBinWrite (AsnIoPtr aip, AsnTypePtr atp, DataValPtr dvp)
{
Int2 isa;
AsnTypePtr atp2;
Boolean terminalvalue;
int next_type;
terminalvalue = TRUE; /* most are terminal values */
if (! AsnTypeValidateOut(aip, atp, dvp))
return FALSE;
atp2 = AsnFindBaseType(atp);
isa = atp2->type->isa;
if (ISA_STRINGTYPE(isa))
isa = GENERALSTRING_TYPE;
if (((isa == SEQ_TYPE) || (isa == SET_TYPE) ||
(isa == SEQOF_TYPE) || (isa == SETOF_TYPE))
&& (dvp->intvalue == END_STRUCT))
{
AsnEnBinCloseStruct(aip, atp);
return TRUE;
}
AsnEnBinTags(atp, aip); /* put in the tags */
if (isa == CHOICE_TYPE) /* show nothing */
{
AsnTypeSetIndent(TRUE, aip, atp);
return TRUE;
}
switch (isa)
{
case SEQ_TYPE:
case SET_TYPE:
case SEQOF_TYPE:
case SETOF_TYPE:
if (dvp->intvalue == START_STRUCT) /* open brace */
AsnEnBinOpenStruct(aip, atp);
else
{
AsnIoErrorMsg(aip, 18 );
return FALSE;
}
terminalvalue = FALSE;
break;
case BOOLEAN_TYPE:
AsnEnBinBoolean(dvp->boolvalue, aip, atp);
break;
case INTEGER_TYPE:
case ENUM_TYPE:
AsnEnBinInteger(dvp->intvalue, aip, atp);
break;
case BIGINT_TYPE:
AsnEnBinBigInt(dvp->bigintvalue, aip, atp);
break;
case REAL_TYPE:
AsnEnBinReal(dvp->realvalue, aip, atp);
break;
case GENERALSTRING_TYPE:
if (! AsnEnBinString((CharPtr) dvp->ptrvalue, aip, atp))
return FALSE;
break;
case NULL_TYPE:
AsnEnBinNull(aip, atp);
break;
case OCTETS_TYPE:
case STRSTORE_TYPE:
AsnEnBinOctets((ByteStorePtr) dvp->ptrvalue, aip, atp);
break;
default:
AsnIoErrorMsg(aip, 19, AsnErrGetTypeName(atp->name));
return FALSE;
}
if (terminalvalue) /* pop out of choice nests */
{
if (atp->tagclass != TAG_NONE)
AsnEnBinEndIndef(aip); /* put indefinate encoding */
next_type = aip->type_indent - 1; /* end any choices */
while ((next_type >= 0) &&
(AsnFindBaseIsa(aip->typestack[next_type].type) == CHOICE_TYPE))
{
if (aip->typestack[next_type].type->tagclass != TAG_NONE)
AsnEnBinEndIndef(aip);
next_type--;
}
if (AsnFindBaseIsa(aip->typestack[aip->type_indent - 1].type) == CHOICE_TYPE)
AsnTypeSetIndent(FALSE, aip, atp);
}
return TRUE;
}
/*****************************************************************************
*
* void AsnTxtBufWrite(aip, atp, buf, buflen)
*
*****************************************************************************/
NLM_EXTERN Boolean LIBCALL AsnTxtBufWrite (AsnIoPtr aip, AsnTypePtr atp, CharPtr buf, size_t buflen)
{
Int2 isa;
AsnTypePtr atp2;
Boolean firstvalue;
if ((! aip->indent_level) && (aip->typestack[0].type == NULL))
firstvalue = TRUE; /* first call to this routine */
else
firstvalue = FALSE;
atp2 = AsnFindBaseType(atp);
isa = atp2->type->isa;
if (ISA_STRINGTYPE(isa))
isa = GENERALSTRING_TYPE;
switch (isa) {
case GENERALSTRING_TYPE:
case OCTETS_TYPE:
case STRSTORE_TYPE:
break;
default:
AsnIoErrorMsg(aip, 19, AsnErrGetTypeName(atp->name));
return FALSE;
}
if (! AsnTypeValidateOut(aip, atp, NULL))
return FALSE;
if (! aip->first[aip->indent_level])
AsnPrintNewLine(aip);
else
aip->first[aip->indent_level] = FALSE;
atp2 = atp;
if (firstvalue) { /* first item, need ::= */
while ((atp2->name == NULL) || (IS_LOWER(*atp2->name)))
atp2 = atp2->type; /* find a Type Reference */
}
if (atp2->name != NULL) {
AsnPrintString(atp2->name, aip); /* put the element name */
if (IS_LOWER(*atp2->name))
AsnPrintChar(' ', aip);
else
AsnPrintString(" ::= ", aip);
}
switch (isa) {
case GENERALSTRING_TYPE:
case STRSTORE_TYPE:
AsnPrintChar('\"', aip);
AsnPrintBuf(buf, buflen, aip);
AsnPrintChar('\"', aip);
break;
case OCTETS_TYPE:
AsnPrintBufOctets(buf, buflen, aip);
break;
default:
AsnIoErrorMsg(aip, 19, AsnErrGetTypeName(atp->name));
return FALSE;
}
if (aip->type_indent) { /* pop out of choice nests */
if (AsnFindBaseIsa(aip->typestack[aip->type_indent - 1].type) == CHOICE_TYPE) {
if (aip->type_indent >= 2)
isa = AsnFindBaseIsa(aip->typestack[aip->type_indent - 2].type);
else
isa = NULL_TYPE; /* just fake it */
AsnPrintIndent(FALSE, aip);
AsnTypeSetIndent(FALSE, aip, atp);
}
}
return TRUE;
}
NLM_EXTERN Int2 LIBCALL AsnTxtReadVal (AsnIoPtr aip, AsnTypePtr atp, DataValPtr valueptr)
{
Int2 isa, token, retval;
Boolean terminalvalue; /* set if read a terminal value */
AsnTypePtr atp2;
Boolean read_value;
DataVal fake_value;
AsnTypePtr base_type, curr_type;
PstackPtr currpsp;
retval = 1; /* assume success */
currpsp = & aip->typestack[aip->type_indent];
curr_type = currpsp->type;
if (atp == NULL)
return 0;
base_type = AsnFindBaseType(atp);
if (base_type == NULL) /* not found */
{
base_type = atp;
while (base_type->type != NULL)
base_type = base_type->type;
if (base_type->imported)
{
AsnIoErrorMsg(aip,35, AsnErrGetTypeName(atp->name), base_type->name, aip->linenumber);
return 0;
}
else
{
AsnIoErrorMsg(aip,36, AsnErrGetTypeName(atp->name), base_type->name, aip->linenumber);
return 0;
}
}
isa = base_type->type->isa;
if (valueptr == NULL) /* just check the value */
{
read_value = FALSE;
valueptr = &fake_value;
}
else
read_value = TRUE;
terminalvalue = TRUE; /* most values are terminal values */
if (ISA_STRINGTYPE(isa) && isa != UTF8STRING_TYPE)
isa = GENERALSTRING_TYPE;
switch (isa)
{
case SEQ_TYPE:
case SET_TYPE:
case SETOF_TYPE:
case SEQOF_TYPE:
terminalvalue = FALSE; /* handled by AsnTypeSetIndent() */
if (aip->token != END_STRUCT) /* should be open brace */
{
token = AsnLexWord(aip); /* read open brace */
if (token != START_STRUCT)
{
AsnIoErrorMsg(aip, 37, aip->linenumber);
return 0;
}
AsnTypeSetIndent(TRUE, aip, atp);
retval = START_STRUCT;
valueptr->intvalue = START_STRUCT;
terminalvalue = FALSE;
}
else
{ /* close brace already read in AsnTxtReadId */
switch (isa)
{
case SEQOF_TYPE:
case SETOF_TYPE:
break;
case SEQ_TYPE: /* check that no more waiting */
if (curr_type != NULL) /* check next one */
atp2 = curr_type->next;
else /* empty sequence written */
atp2 = (AsnTypePtr)base_type->branch;
while (atp2 != NULL)
{
if (! (atp2->optional || atp2->hasdefault))
{
AsnIoErrorMsg(aip, 34, AsnErrGetTypeName(atp2->name), base_type->name, aip->linenumber);
return 0;
}
atp2 = atp2->next;
}
break;
default:
break;
}
AsnTypeSetIndent(FALSE, aip, atp);
retval = END_STRUCT;
valueptr->intvalue = END_STRUCT;
}
break;
case CHOICE_TYPE:
AsnTypeSetIndent(TRUE, aip, atp); /* nest down to type */
terminalvalue = FALSE;
break;
case BOOLEAN_TYPE:
valueptr->boolvalue = AsnLexReadBoolean(aip, atp);
break;
case INTEGER_TYPE:
case ENUM_TYPE:
valueptr->intvalue = AsnLexReadInteger(aip, atp);
break;
case BIGINT_TYPE:
valueptr->bigintvalue = AsnLexReadBigInt(aip, atp);
break;
case REAL_TYPE:
valueptr->realvalue = AsnLexReadReal(aip, atp);
break;
case GENERALSTRING_TYPE:
if (read_value)
{
valueptr->ptrvalue = AsnLexReadString(aip, atp);
if (valueptr->ptrvalue == NULL)
return 0;
}
else
{
if (! AsnLexSkipString(aip, atp))
return 0;
}
break;
case UTF8STRING_TYPE:
if (read_value)
{
valueptr->ptrvalue = AsnLexReadStringUTF8(aip, atp);
if (valueptr->ptrvalue == NULL)
return 0;
}
else
{
if (! AsnLexSkipStringUTF8(aip, atp))
return 0;
}
break;
case NULL_TYPE:
AsnLexReadNull(aip, atp);
break;
case OCTETS_TYPE:
if (read_value)
{
valueptr->ptrvalue = AsnLexReadOctets(aip, atp);
if (valueptr->ptrvalue == NULL) return 0;
}
else
AsnLexSkipOctets(aip, atp);
break;
case STRSTORE_TYPE:
if (read_value)
{
valueptr->ptrvalue = (ByteStorePtr) AsnLexReadString(aip, atp);
if (valueptr->ptrvalue == NULL)
return 0;
}
else
{
if (! AsnLexSkipString(aip, atp))
return 0;
}
break;
default:
AsnIoErrorMsg(aip, 38, AsnErrGetTypeName(atp->name),aip->linenumber);
return 0;
}
if (terminalvalue) /* pop out of any CHOICE nests */
{
while ((aip->type_indent) &&
(AsnFindBaseIsa(aip->typestack[aip->type_indent - 1].type) == CHOICE_TYPE))
AsnTypeSetIndent(FALSE, aip, atp);
}
return retval;
}
