/*****************************************************************************
*
* Int4 AsnLexReadInteger(aip, atp)
* expects an INTEGER or ENUMERATED next
* assumes none of it has already been read
* does not advance to next token
* atp points to the definition of this integer for named values
*
*****************************************************************************/
NLM_EXTERN Int4 AsnLexReadInteger (AsnIoPtr aip, AsnTypePtr atp)
{
Int2 token;
AsnValxNodePtr avnp;
AsnTypePtr atp2;
token = AsnLexWord(aip); /* read the integer */
if (token == NUMBER) /* just a number */
{
return AsnLexInteger(aip);
}
if (token != IDENT) /* not number or named value */
{
AsnIoErrorMsg(aip, 39, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
/******************** read a named integer value *********/
atp2 = AsnFindBaseType(atp);
if (atp2->branch != NULL) /* named values */
{
avnp = (AsnValxNodePtr) atp2->branch;
while (avnp != NULL)
{
if (StrMatch(avnp->name, aip->word, aip->wordlen))
return avnp->intvalue;
avnp = avnp->next;
}
}
if (atp2->type->isa == ENUM_TYPE) /* enumerated MUST match named value */
{
AsnIoErrorMsg(aip, 40, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
/******************* could it be a previously defined value? ***/
AsnIoErrorMsg(aip, 41, AsnErrGetTypeName(atp->name), aip->linenumber);
return 0;
}
/*****************************************************************************
*
* Int2 AsnLexTReadType(aip, amp, atp)
* reads a type assignment for one type
* assumes has read name already
* assumes has read next input item after name
* returns token to following item
* returns 0 on error
*
*****************************************************************************/
NLM_EXTERN Int2 AsnLexTReadType (AsnIoPtr aip, AsnModulePtr amp, AsnTypePtr atp)
{
Int2 isa;
Boolean first;
AsnValxNodePtr avnp, prevavnp;
Int2 token;
token = aip->token;
if (token == COMMENT_TOKEN)
{
AsnLexTAddTypeComment(aip, &(atp->hints));
token = AsnLexTWord(aip);
}
if (token == IMPLICIT_TOKEN)
{
atp->implicit = TRUE;
token = AsnLexTWord(aip);
}
if (token == START_TAG) /* TAG */
{
token = AsnLexTWord(aip);
if (ISA_TAGCLASS(token))
{
switch (token)
{
case UNIV_TAG_TOKEN:
atp->tagclass = TAG_UNIVERSAL;
break;
case PRIV_TAG_TOKEN:
atp->tagclass = TAG_PRIVATE;
break;
case AP_TAG_TOKEN:
atp->tagclass = TAG_APPLICATION;
break;
}
token = AsnLexTWord(aip);
}
else
atp->tagclass = TAG_CONTEXT;
if (token == NUMBER)
{
atp->tagnumber = (Int2) AsnLexInteger(aip);
token = AsnLexTWord(aip);
if (token != END_TAG)
{
AsnIoErrorMsg(aip, 61, aip->linenumber);
return 0;
}
else
token = AsnLexTWord(aip);
}
else if (token == IDENT)
{
AsnIoErrorMsg(aip, 62, aip->linenumber);
return 0;
}
else
{
AsnIoErrorMsg(aip, 63, aip->linenumber);
return 0;
}
}
atp->type = AsnGetType(aip, amp);
isa = atp->type->isa;
token = AsnLexTWord(aip); /* read next token */
AsnLexTAddTypeComment(aip, &(atp->hints)); /* check for stored comments */
if (token == COMMENT_TOKEN)
token = AsnLexTWord(aip);
/*********** SubType Processing *********************/
if (token == OPEN_PAREN)
{
AsnIoErrorMsg(aip, 64, aip->linenumber);
return 0;
}
/******************* process various types *********/
if (isa < 400) /* operate on builtin types */
switch (isa)
{
case INTEGER_TYPE: /* check for named integers */
if (token != START_STRUCT)
break;
case ENUM_TYPE:
if (token != START_STRUCT)
{
AsnIoErrorMsg(aip, 65, aip->linenumber);
return 0;
}
/* read named integers */
first = TRUE;
avnp = NULL;
prevavnp = NULL;
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
AsnLexTAddTypeComment(aip, &(atp->hints)); /* check for stored comments */
token = AsnLexTWord(aip);
}
while (token != END_STRUCT)
{
avnp = AsnValxNodeNew(avnp, VALUE_ISA_NAMED_INT);
if (! first)
{
if (token != COMMA)
{
AsnIoErrorMsg(aip, 66, aip->linenumber);
return 0;
}
else
{
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
AsnLexTAddTypeComment(aip, &(prevavnp->aop));
token = AsnLexTWord(aip);
}
}
}
else
{
first = FALSE;
atp->branch = avnp;
}
if (token != IDENT)
{
AsnIoErrorMsg(aip, 86, aip->linenumber);
return 0;
}
avnp->name = AsnLexSaveWord(aip);
token = AsnLexTWord(aip);
if (token != OPEN_PAREN)
{
AsnIoErrorMsg(aip, 87, aip->linenumber);
return 0;
}
avnp->intvalue = AsnLexReadInteger(aip, atp);
token = AsnLexTWord(aip);
if (token != CLOSE_PAREN)
{
AsnIoErrorMsg(aip, 88, aip->linenumber);
return 0;
}
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
token = AsnLexTWord(aip);
AsnLexTAddTypeComment(aip, &(avnp->aop)); /* check for stored comments */
prevavnp = avnp;
}
token = AsnLexTWord(aip);
if (token == COMMENT_TOKEN)
{
AsnLexTAddTypeComment(aip, &(prevavnp->aop));
token = AsnLexTWord(aip);
}
break;
case SETOF_TYPE: /* create branch for type */
case SEQOF_TYPE:
atp->branch = AsnElementTypeNew(NULL); /* get unnamed element for type */
token = AsnLexTReadType(aip, amp, (AsnTypePtr) atp->branch);
break;
case SEQ_TYPE:
case SET_TYPE:
atp->branch = AsnLexTReadElementTypeList(aip, amp, atp);
token = aip->token;
break;
case CHOICE_TYPE:
atp->branch = AsnLexTReadAlternativeTypeList(aip, amp, atp);
token = aip->token;
break;
}
atp->resolved = TRUE;
return token;
}
