/*****************************************************************************
*
* AsnTypePtr AsnLexTReadElementTypeList(aip, amp)
* assumes has read first { already
* returns token to following element
*
*****************************************************************************/
NLM_EXTERN AsnTypePtr AsnLexTReadElementTypeList (AsnIoPtr aip, AsnModulePtr amp, AsnTypePtr parent)
{
Int2 token;
AsnTypePtr atp, atp1, atplast, atp2;
AsnValxNodePtr avnp;
token = aip->token;
atp1 = NULL;
atplast = NULL;
if (token != START_STRUCT)
{
AsnIoErrorMsg(aip, 37, aip->linenumber);
return NULL;
}
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
if (parent != NULL)
AsnLexTAddTypeComment(aip, &(parent->hints));
token = AsnLexTWord(aip);
}
while (token != END_STRUCT)
{
if (atp1 != NULL) /* not the first */
{
if (token != COMMA)
{
AsnIoErrorMsg(aip, 66, aip->linenumber);
return NULL;
}
else
{
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
if (atplast != NULL)
AsnLexTAddTypeComment(aip, &(atplast->hints));
token = AsnLexTWord(aip);
}
}
}
if (token == COMPS_TOKEN) /* COMPONENTS OF */
{
AsnIoErrorMsg(aip, 93, aip->linenumber);
return NULL;
}
else if (token != IDENT) /* not named */
{
atp = AsnElementTypeNew(NULL);
}
else /* named Type */
{
atp = AsnElementTypeNew(aip);
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
AsnLexTAddTypeComment(aip, &(atp->hints));
token = AsnLexTWord(aip);
}
}
/* add to chain */
if (atp1 == NULL)
atp1 = atp;
else
atplast->next = atp;
token = AsnLexTReadType(aip, amp, atp);
if (token == OPTIONAL_TOKEN) /* OPTIONAL */
{
atp->optional = TRUE;
token = AsnLexTWord(aip);
}
else if (token == DEFAULT_TOKEN) /* DEFAULT */
{
atp->hasdefault = TRUE;
avnp = AsnValxNodeNew(NULL, VALUE_ISA_BOOL);
atp->defaultvalue = avnp;
/* read the default value */
atp2 = AsnFindBaseType(atp);
if (atp2 == NULL)
{
AsnIoErrorMsg(aip, 95, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
switch (atp2->type->isa)
{
case BOOLEAN_TYPE:
avnp->intvalue = (Int4) AsnLexReadBoolean(aip, atp2);
break;
case INTEGER_TYPE:
case ENUM_TYPE:
avnp->valueisa = VALUE_ISA_INT;
avnp->intvalue = AsnLexReadInteger(aip, atp2);
break;
case VISIBLESTRING_TYPE:
avnp->valueisa = VALUE_ISA_PTR;
avnp->name = (CharPtr) AsnLexReadString(aip, atp2);
break;
case REAL_TYPE:
avnp->valueisa = VALUE_ISA_REAL;
avnp->realvalue = AsnLexReadReal(aip, atp2);
break;
default:
AsnIoErrorMsg(aip, 94, AsnErrGetTypeName(atp->name));
return NULL;
}
token = AsnLexTWord(aip);
}
atplast = atp;
AsnLexTAddTypeComment(aip, &(atplast->hints));
if (token == COMMENT_TOKEN)
token = AsnLexTWord(aip);
}
token = AsnLexTWord(aip); /* read following item */
if (token == COMMENT_TOKEN)
{
if (atplast != NULL)
AsnLexTAddTypeComment(aip, &(atplast->hints));
token = AsnLexTWord(aip);
}
return atp1;
}
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;
}