/*****************************************************************************
*
* 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;
}
/*****************************************************************************
*
* 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;
}