/***************************************************************************** * * Int8 AsnLexReadBigInt(aip, atp) * expects an INTEGER 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 Int8 AsnLexReadBigInt (AsnIoPtr aip, AsnTypePtr atp) { Int2 token; token = AsnLexWord(aip); /* read the integer */ if (token == NUMBER) /* just a number */ { return AsnLexBigInt(aip); } if (token != IDENT) /* not number or named value */ { AsnIoErrorMsg(aip, 39, AsnErrGetTypeName(atp->name), aip->linenumber); return 0; } /******************** read a named integer value *********/ /**** not supported for bigint *****/ /******************* could it be a previously defined value? ***/ AsnIoErrorMsg(aip, 41, AsnErrGetTypeName(atp->name), aip->linenumber); return (Int8)0; }
/***************************************************************************** * * void AsnLexSkipOctets(aip, atp) * expects Octets type next * assumes none of it has already been read * does not advance to next token * atp points to the definition of this OCTET STRING * *****************************************************************************/ NLM_EXTERN void AsnLexSkipOctets (AsnIoPtr aip, AsnTypePtr atp) { Int2 token, left, len; Int4 line; token = AsnLexWord(aip); /* read the start */ if (token != START_BITHEX) { AsnIoErrorMsg(aip, 45, AsnErrGetTypeName(atp->name), aip->linenumber); return; } line = aip->linenumber; token = AsnLexWord(aip); /* read the octet(s) */ left = 0; while (token == IN_BITHEX) { len = aip->wordlen + left; left = len % 2; token = AsnLexWord(aip); } if (left) { AsnIoErrorMsg(aip, 48, AsnErrGetTypeName(atp->name), line); return; } if (token != OCTETS) AsnIoErrorMsg(aip, 47, AsnErrGetTypeName(atp->name), aip->linenumber); return; }
/***************************************************************************** * * ByteStorePtr AsnLexReadOctets(aip, atp) * expects Octets type next * assumes none of it has already been read * does not advance to next token * atp points to the definition of this OCTET STRING * *****************************************************************************/ NLM_EXTERN ByteStorePtr AsnLexReadOctets (AsnIoPtr aip, AsnTypePtr atp) { Int2 token, len; ByteStorePtr ssp = NULL; Byte tbuf[256]; /* was 101 - changed to handle occasional hand-edited ASN.1? */ Int4 bytes, left, added; token = AsnLexWord(aip); /* read the start */ if (token != START_BITHEX) { AsnIoErrorMsg(aip, 45, AsnErrGetTypeName(atp->name), aip->linenumber); return NULL; } ssp = BSNew(0); if (ssp == NULL) return ssp; token = AsnLexWord(aip); /* read the octet(s) */ left = 0; while (token == IN_BITHEX) { len = (Int2)(aip->wordlen + left); MemCopy((tbuf + left), aip->word, (len - left)); tbuf[len] = '\0'; added = AsnTypeStringToHex(tbuf, len, tbuf, &left); if (added < 0) { AsnIoErrorMsg(aip, 46, AsnErrGetTypeName(atp->name), aip->linenumber); return NULL; } if (added) { bytes = BSWrite(ssp, tbuf, added); if (bytes != added) { ssp = BSFree(ssp); return ssp; } } if (left) /* left a char */ { MemCopy(tbuf, ((aip->word)+(aip->wordlen - left)),left); } token = AsnLexWord(aip); } if (token != OCTETS) { AsnIoErrorMsg(aip, 47, AsnErrGetTypeName(atp->name), aip->linenumber); return NULL; } return ssp; }
/***************************************************************************** * * void AsnLexSkipStruct(aip) * skips current structure and all substructures * Does NOT read following element * *****************************************************************************/ NLM_EXTERN void AsnLexSkipStruct (AsnIoPtr aip) { int type_indent = 1; Int2 token; while (type_indent) { token = AsnLexWord(aip); switch (token) { case START_STRUCT: /* another substructure */ type_indent++; break; case END_STRUCT: /* a close brace */ type_indent--; break; case EOF_TOKEN: AsnIoErrorMsg(aip, 17); return; default: break; } } return; }
/***************************************************************************** * * Int2 AsnLexTReadTypeAssign(aip, amp) * reads a type assignment for one type * assumes has read name already * returns token to following item * returns 0 on error * *****************************************************************************/ NLM_EXTERN Int2 AsnLexTReadTypeAssign (AsnIoPtr aip, AsnModulePtr amp) { AsnTypePtr atp; Int2 token; AsnOptionPtr aop; /* store the typereference */ atp = AsnTypeNew(aip, amp); aop = AsnIoOptionGet(aip, OP_TYPEORDER, 0, NULL); if (aop != NULL) /* add ordered display */ { AsnOptionNew(&(atp->hints), OP_TYPEORDER, 0, aop->data, NULL); aop->data.intvalue++; } if ((token = AsnLexTWord(aip)) != ISDEF) { AsnIoErrorMsg(aip, 28, aip->linenumber); return 0; } token = AsnLexTWord(aip); /* get next element */ token = AsnLexTReadType(aip, amp, atp); return token; }
/***************************************************************************** * * AsnTypePtr AsnTypeFind(amp, str) * finds a type in a module or set of modules * str is a path with dot separation. * E is used to indicate an element of SEQOF or SETOF * looks for partial paths as well * * if called with amp == NULL * searches all loaded modules * returns a single node at the end of the path * *****************************************************************************/ NLM_EXTERN AsnTypePtr LIBCALL AsnTypeFind (AsnModulePtr amp, CharPtr str) { AsnModulePtr amp2; AsnTypePtr atp; if (amp == NULL) { if (amps == NULL) { AsnIoErrorMsg(NULL, (Int2)105); return NULL; } amp = (AsnModulePtr) amps->data.ptrvalue; } amp2 = amp; atp = NULL; while (amp2 != NULL) { atp = AsnTypeFindType(amp2->types, str, NULL, 0, FALSE); if (atp != NULL) return atp; else amp2 = amp2->next; } return atp; /* not found */ }
NLM_EXTERN AsnIoConnPtr QUERY_AsnIoConnOpen ( const char* mode, CONN conn ) { Int1 type; AsnIoConnPtr aicp; if (strcmp(mode, "r") == 0) type = (ASNIO_IN | ASNIO_TEXT); else if (strcmp(mode, "rb") == 0) type = (ASNIO_IN | ASNIO_BIN); else if (strcmp(mode, "w") == 0) type = (ASNIO_OUT | ASNIO_TEXT); else if (strcmp(mode, "wb") == 0) type = (ASNIO_OUT | ASNIO_BIN); else { AsnIoErrorMsg (NULL, 81, mode); return NULL; } aicp = (AsnIoConnPtr) MemNew (sizeof (AsnIoConn)); aicp->aip = AsnIoNew (type, NULL, (Pointer) aicp, AsnIoConnRead, AsnIoConnWrite); aicp->conn = conn; return aicp; }
/***************************************************************************** * * 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; }
/***************************************************************************** * * void AsnLexReadNull(aip, atp) * *****************************************************************************/ NLM_EXTERN void AsnLexReadNull (AsnIoPtr aip, AsnTypePtr atp) { AsnLexWord(aip); if (! StrMatch("NULL", aip->word, aip->wordlen)) { AsnIoErrorMsg(aip, 57, AsnErrGetTypeName(atp->name), aip->linenumber); return; } return; }
static Pointer AsnLexReadStringEx (AsnIoPtr aip, AsnTypePtr atp, Uint1 fix_non_print) { Int2 token; ByteStorePtr ssp; CharPtr result=NULL; Int4 bytes; token = AsnLexWordEx (aip, fix_non_print); /* read the start */ if (token != START_STRING) { AsnIoErrorMsg(aip, 43, AsnErrGetTypeName(atp->name), aip->linenumber); return NULL; } ssp = BSNew(0); if (ssp == NULL) return result; token = AsnLexWordEx (aip, fix_non_print); /* read the string(s) */ while (token == IN_STRING) { bytes = BSWrite(ssp, aip->word, (Int4)aip->wordlen); if (bytes != (Int4)(aip->wordlen)) { BSFree(ssp); return result; } token = AsnLexWord(aip); } if (token == ERROR_TOKEN) return NULL; if (token != END_STRING) { AsnIoErrorMsg(aip, 44, AsnErrGetTypeName(atp->name), aip->linenumber); return NULL; } if (AsnFindBaseIsa(atp) == STRSTORE_TYPE) /* string store */ return ssp; result = (CharPtr) BSMerge(ssp, NULL); BSFree(ssp); return result; }
/***************************************************************************** * * AsnEnumStr(type, val) * *****************************************************************************/ NLM_EXTERN CharPtr LIBCALL AsnEnumStr (CharPtr type, Int2 val) { AsnTypePtr atp; if (amps == NULL) { AsnIoErrorMsg(NULL, (Int2)105); return NULL; } atp = AsnTypeFind((AsnModulePtr)amps->data.ptrvalue, type); return AsnEnumTypeStr(atp, val); }
/***************************************************************************** * * AsnTypePtr AsnGetType(aip, amp) * return pointer to type of last element read * *****************************************************************************/ NLM_EXTERN AsnTypePtr AsnGetType (AsnIoPtr aip, AsnModulePtr amp) { AsnTypePtr atp; AsnPrimTypePtr aptp; Int2 wordlen; Int2 token; wordlen = aip->wordlen; token = aip->token; if (ISA_ASNTYPE(aip->token)) /* a primitive */ { aptp = asnprimtypes; while (aptp->isa != token) aptp++; return (AsnTypePtr)aptp; } else if (ISA_BASETYPE(aip->token)) /* an application type */ { aptp = asnapptypes; while (aptp->isa != token) aptp++; return (AsnTypePtr)aptp; } if (aip->token != REF) /* not a type */ { AsnIoErrorMsg(aip, 98, aip->word, aip->linenumber); return NULL; } /**************** not a primitive - do we have it already? *******/ atp = amp->types; while (atp != NULL) { if (StrMatch(atp->name, aip->word, wordlen)) /* it matches */ { if (atp->imported == TRUE) /* reference to imported type */ atp->resolved = TRUE; return atp; } else atp = atp->next; } /*************** not defined - add unresolved node *************/ atp = AsnTypeNew(aip, amp); return atp; }
/***************************************************************************** * * AsnTypePtr AsnTypeNew(aip, amp) * *****************************************************************************/ NLM_EXTERN AsnTypePtr AsnTypeNew (AsnIoPtr aip, AsnModulePtr amp) { AsnTypePtr atp, next; Int2 token; next = amp->types; atp = amp->types; if ((token = AsnLexTMatchToken(aip)) != 0) /* it's a reserved word */ AsnIoErrorMsg(aip, 67, asnwords[token - 1], aip->linenumber); while (next != NULL) { atp = next; next = atp->next; if (StrMatch(atp->name, aip->word, aip->wordlen)) /* already used name */ { if (! atp->resolved) /* needs to be resolved yet, so OK */ return atp; else /* already defined */ { AsnIoErrorMsg(aip, 99, AsnErrGetTypeName(atp->name), aip->linenumber); } } } next = (AsnTypePtr) MemNew(sizeof(AsnType)); next->tagclass = TAG_NONE; /* default tag class */ next->name = AsnLexSaveWord(aip); amp->lasttype++; /* increment defined types isa */ next->isa = amp->lasttype; if (atp == NULL) /* first one */ amp->types = next; else atp->next = next; return next; }
static Boolean AsnLexSkipStringEx (AsnIoPtr aip, AsnTypePtr atp, Uint1 fix_non_print) { Int2 token; token = AsnLexWordEx(aip, fix_non_print); /* read the start */ if (token != START_STRING) { AsnIoErrorMsg(aip, 43, AsnErrGetTypeName(atp->name), aip->linenumber); return FALSE; } token = AsnLexWordEx(aip, fix_non_print); /* read the string(s) */ while (token == IN_STRING) token = AsnLexWord(aip); if (token == ERROR_TOKEN) return FALSE; if (token != END_STRING) AsnIoErrorMsg(aip, 44, AsnErrGetTypeName(atp->name), aip->linenumber); return TRUE; }
/***************************************************************************** * * Boolean AsnLexReadBoolean(aip, atp) * expects a BOOLEAN next * assumes none of it has already been read * does not advance to next token * atp points to the definition of this BOOLEN * *****************************************************************************/ NLM_EXTERN Boolean AsnLexReadBoolean (AsnIoPtr aip, AsnTypePtr atp) { AsnLexWord(aip); /* read the boolean */ if (StrMatch("TRUE", aip->word, aip->wordlen)) return TRUE; else if (StrMatch("FALSE", aip->word, aip->wordlen)) return FALSE; AsnIoErrorMsg(aip, 42, AsnErrGetTypeName(atp->name), aip->linenumber); return FALSE; /* just for lint */ }
/***************************************************************************** * * AsnModulePtr AsnCheckModule(amp, aip) * *****************************************************************************/ NLM_EXTERN AsnModulePtr AsnCheckModule (AsnModulePtr amp, AsnIoPtr aip) { AsnTypePtr atp; Boolean ok = TRUE; atp = amp->types; /* check that everything got resolved */ while (atp != NULL) { if (atp->resolved != TRUE) { if (atp->imported != TRUE) /* only imported not resolved */ { AsnIoErrorMsg(aip, 100, AsnErrGetTypeName(atp->name), amp->modulename); ok = FALSE; } else AsnIoErrorMsg(aip, 101, AsnErrGetTypeName(atp->name), amp->modulename); } if (atp->imported == TRUE) { if (atp->branch == NULL) { AsnIoErrorMsg(aip, 102, AsnErrGetTypeName(atp->name), amp->modulename); ok = FALSE; } } atp = atp->next; } AsnSetTags(amp->types); /* assign tags */ if (ok) return amp; else return NULL; }
/***************************************************************************** * * AsnTypePathFind(amp, str, countptr) * like AsnTypeFind() but allocates an array of AsnTypePtr and fills * it in with the proper path. Sets countptr to sizeof array. * Returns array or NULL on failure * *****************************************************************************/ NLM_EXTERN AsnTypePtr PNTR LIBCALL AsnTypePathFind (AsnModulePtr amp, CharPtr str, Int2Ptr countptr) { AsnModulePtr amp2; AsnTypePtr atp; Int2 count; AsnTypePtr PNTR typeptr; CharPtr ptr; *countptr = 0; count = 1; ptr = str; while (*ptr != '\0') { if (*ptr == '.') count++; ptr++; } typeptr = (AsnTypePtr*) MemNew(sizeof(AsnTypePtr) * count); if (amp == NULL) { if (amps == NULL) { AsnIoErrorMsg(NULL, (Int2)105); return NULL; } amp = (AsnModulePtr) amps->data.ptrvalue; } amp2 = amp; atp = NULL; while (amp2 != NULL) { atp = AsnTypeFindType(amp2->types, str, typeptr, count, FALSE); if (atp != NULL) { *countptr = count; return typeptr; } else amp2 = amp2->next; } MemFree(typeptr); return NULL; /* not found */ }
/***************************************************************************** * * AsnLexTReadModule(aip) * *****************************************************************************/ NLM_EXTERN AsnModulePtr AsnLexTReadModule (AsnIoPtr aip) { AsnModulePtr amp; AsnOptionPtr aop; DataVal dv; /* get name and look for valid start */ amp = AsnLexTStartModule(aip); if (amp == NULL) return amp; aop = AsnIoOptionGet(aip, OP_TYPEORDER, 0, NULL); if (aop == NULL) { MemSet(&dv, 0, sizeof(DataVal)); aop = AsnIoOptionNew(aip, OP_TYPEORDER, 0, dv, NULL); } aop->data.intvalue = 1; /* start the order counter */ /* scan declarations */ while (aip->token != END_TOKEN) /* END */ { if (aip->token == REF) /* its a type assignment */ aip->token = AsnLexTReadTypeAssign(aip, amp); /**************************** not implemented yet ******** else if (token == IDENT) aip->token = AsnReadDefinedValue(aip, amp); **********************************************************/ else { AsnIoErrorMsg(aip, 60, aip->linenumber, aip->word); return NULL; } } amp = AsnCheckModule(amp, aip); return amp; }
/***************************************************************************** * * 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; }
/***************************************************************************** * * AsnModulePtr AsnLexTStartModule(aip) * if $Revision: in comment in first line of file, puts the string * containing the revision number in amp->filename * if --$Revision: X.YY * stores "YY" * if --$Revision: X.Y stores "XY" * if --$Revision: X * stores "X" * *****************************************************************************/ NLM_EXTERN AsnModulePtr AsnLexTStartModule (AsnIoPtr aip) { Int2 token; AsnModulePtr amp; Int2 asntype; AsnTypePtr atp; Boolean wasref; Char buf[10]; CharPtr from, to; Int2 len; amp = (AsnModulePtr) MemNew(sizeof(AsnModule)); token = AsnLexTWord(aip); /* get the module name or $Revision: */ while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token == REVISION_TOKEN) /* revision of file */ { to = buf; *to = '\0'; len = (Int2)(aip->wordlen); if (len == 4) /* x.yy */ { from = aip->word + 2; len -= 2; } else from = aip->word; if (len) { if (IS_DIGIT(*from)) { *to = *from; to++; from++;len--; } while ((len) && (! IS_DIGIT(*from))) { len--; from++; } if ((len) && (IS_DIGIT(*from))) { *to = *from; to++; } *to = '\0'; amp->filename = StringSave(buf); } token = AsnLexTWord(aip); /* get the module name */ while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } } if (token != REF) { MemFree(amp->filename); amp = (AsnModulePtr) MemFree(amp); return amp; } if ((asntype = AsnLexTMatchToken(aip)) != 0) /* any predefined value is wrong */ { AsnIoErrorMsg(aip, 67, asnwords[asntype -1], aip->linenumber); return NULL; } /* create a new module */ amp->modulename = AsnLexSaveWord(aip); amp->lasttype = 400; amp->lastvalue = 10000; token = AsnLexTWord(aip); while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token == START_STRUCT) /* it has an object identifier */ { AsnIoErrorMsg(aip, 68); /* skip object identifier */ AsnLexSkipStruct(aip); token = AsnLexTWord(aip); /* next token */ } while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token != DEF_TOKEN) /* DEFINITIONS */ { AsnIoErrorMsg(aip, 69, asnwords[DEF_TOKEN - 401], aip->linenumber); return NULL; } else token = AsnLexTWord(aip); while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } while (token != ISDEF && token != BEGIN_TOKEN && token != ERROR_TOKEN) { token = AsnLexTWord(aip); } if (token != ISDEF) /* ::= */ { AsnIoErrorMsg(aip, 69, "::=", aip->linenumber); return NULL; } else token = AsnLexTWord(aip); while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token != BEGIN_TOKEN) /* BEGIN */ { AsnIoErrorMsg(aip, 69, asnwords[BEGIN_TOKEN - 401], aip->linenumber); return NULL; } else token = AsnLexTWord(aip); while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token == EXPORTS_TOKEN) /* read any EXPORTS */ { wasref = FALSE; while ((token = AsnLexTWord(aip)) != SEMI_COLON) { if (token == REF) /* should be REF */ { if (wasref) { AsnIoErrorMsg(aip, 66, aip->linenumber); return NULL; } atp = AsnTypeNew(aip, amp); atp->exported = TRUE; wasref = TRUE; } else if (token == COMMA) { if (! wasref) { AsnIoErrorMsg(aip, 70, aip->linenumber); return NULL; } wasref = FALSE; } else if (token != COMMENT_TOKEN) { AsnIoErrorMsg(aip, 59, ' ', aip->linenumber); return NULL; } } /* get next after semi-colon */ token = AsnLexTWord(aip); } while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token == IMPORTS_TOKEN) /* IMPORTS */ { wasref = FALSE; token = AsnLexTWord(aip); while (token != SEMI_COLON) { if (token == REF) /* should be REF */ { atp = AsnTypeNew(aip, amp); atp->imported = TRUE; wasref = TRUE; } else if (token == COMMA) { if (! wasref) { AsnIoErrorMsg(aip, 70, aip->linenumber); return NULL; } wasref = FALSE; } else if (token == FROM_TOKEN) { if (! wasref) { AsnIoErrorMsg(aip, 71, aip->linenumber); return NULL; } else /* read source module */ token = AsnLexTWord(aip); if (token != REF) { AsnIoErrorMsg(aip, 72, aip->linenumber); return NULL; } else { atp = amp->types; while (atp != NULL) { if ((atp->imported == TRUE) && (atp->branch == NULL)) atp->branch = AsnLexSaveWord(aip); atp = atp->next; } } wasref = FALSE; } else if (token == START_STRUCT) { AsnIoErrorMsg(aip, 73, aip->linenumber); AsnLexSkipStruct(aip); token = AsnLexTWord(aip); wasref = FALSE; } else if (token != COMMENT_TOKEN) AsnIoErrorMsg(aip, 96, aip->linenumber); token = AsnLexTWord(aip); } /* get next after semi-colon */ token = AsnLexTWord(aip); } while (token == COMMENT_TOKEN) { token = AsnLexTWord(aip); } if (token == EXPORTS_TOKEN) /* EXPORTS out of place */ AsnIoErrorMsg(aip, 97, aip->linenumber); return amp; }
/***************************************************************************** * * AsnTypePtr AsnLexTReadAlternativeTypeList(aip, amp, parent) * assumes has read first { already * returns token to following element * *****************************************************************************/ NLM_EXTERN AsnTypePtr AsnLexTReadAlternativeTypeList (AsnIoPtr aip, AsnModulePtr amp, AsnTypePtr parent) { Int2 token; AsnTypePtr atp, atp1, atplast; 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 != 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); 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; }
/***************************************************************************** * * 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; }
/***************************************************************************** * * 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; }
/***************************************************************************** * * FloatHi AsnLexReadReal(aip, atp) * expects a REAL next * assumes none of it has already been read * does not advance to next token * atp points to the definition of this REAL * *****************************************************************************/ NLM_EXTERN FloatHi AsnLexReadReal (AsnIoPtr aip, AsnTypePtr atp) { Int2 token; double mantissa, result; int base, exponent; char buf[15]; result = 0.0; token = AsnLexWord(aip); /* read the { */ if (token != START_STRUCT) { AsnIoErrorMsg(aip, 49, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } token = AsnLexWord(aip); /* read mantissa */ if (token != NUMBER) { AsnIoErrorMsg(aip, 50, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } MemCopy(buf, aip->word, (size_t)aip->wordlen); buf[aip->wordlen] = '\0'; mantissa = atof(buf); token = AsnLexWord(aip); /* read comma */ if (token != COMMA) { AsnIoErrorMsg(aip, 51, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } token = AsnLexWord(aip); /* read base */ if (token != NUMBER) { AsnIoErrorMsg(aip, 52, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } MemCopy(buf, aip->word, (size_t)aip->wordlen); buf[aip->wordlen] = '\0'; base = atoi(buf); if ((base != 2) && (base != 10)) { AsnIoErrorMsg(aip, 53, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } token = AsnLexWord(aip); if (token != COMMA) { AsnIoErrorMsg(aip, 54, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } token = AsnLexWord(aip); if (token != NUMBER) { AsnIoErrorMsg(aip, 55, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } MemCopy(buf, aip->word, (size_t)aip->wordlen); buf[aip->wordlen] = '\0'; exponent = atoi(buf); token = AsnLexWord(aip); if (token != END_STRUCT) { AsnIoErrorMsg(aip, 56, AsnErrGetTypeName(atp->name), aip->linenumber); return (FloatHi)result; } if (base == 10) /* range checking only on base 10, for doubles */ { if (exponent > DBL_MAX_10_EXP) /* exponent too big */ return (FloatHi)DBL_MAX; else if (exponent < DBL_MIN_10_EXP) /* exponent too small */ return (FloatHi)result; } result = mantissa * Nlm_Powi((double)base, exponent); return (FloatHi)result; }
/***************************************************************************** * * void AsnModuleLink(amp) * links IMPORT types with EXPORTS from other modules * if cannot link an IMPORT, no errors are generated * *****************************************************************************/ NLM_EXTERN void LIBCALL AsnModuleLink (AsnModulePtr amp) { AsnTypePtr atp, atp2, typestack[10]; AsnModulePtr currmod, mod; Boolean found; currmod = amp; while (currmod != NULL) { atp = currmod->types; while (atp != NULL) { if ((atp->imported) && (atp->type == NULL)) /* link imported types */ { mod = amp; if (mod == currmod) mod = mod->next; found = FALSE; while ((mod != NULL) && (! found)) { atp2 = mod->types; while ((atp2 != NULL) && (! found)) { if ((! atp2->imported) && (! StringCmp(atp2->name, atp->name))) { if (atp2->exported) { atp->type = atp2; found = TRUE; } else { AsnIoErrorMsg(NULL, 84, AsnErrGetTypeName(atp2->name), mod->modulename); atp2 = atp2->next; } } else atp2 = atp2->next; } mod = mod->next; if (mod == currmod) mod = mod->next; } } atp = atp->next; } currmod = currmod->next; } /*** Fill in the XML names *********/ currmod = amp; while (currmod != NULL) { atp = currmod->types; while (atp != NULL) { AddXMLname(atp, typestack, (Int2)0); atp = atp->next; } currmod = currmod->next; } return; }
/***************************************************************************** * * AsnTreeLoad(file, &avn, &at, &) * *****************************************************************************/ NLM_EXTERN Boolean LIBCALL AsnTreeLoad (char *file, AsnValxNodePtr *avnptr, AsnTypePtr *atptr, AsnModulePtr *ampptr) { AsnValxNodePtr avn = NULL, avncurr; AsnTypePtr at = NULL, atcurr; AsnModulePtr amp = NULL, ampcurr; ValNodePtr anp, ampanp; int numval, numtype, nummod, i; FILE * fp; int isa, next; long intvalue; double realvalue; char name[PATH_MAX], fname[60]; CharPtr ptr; int bools[5], tagclass, tagnumber, defaultvalue, type, branch; /* check to see if we already have it (could happen) */ anp = names; ampanp = amps; while (anp != NULL) { if (! StringCmp((CharPtr)anp->data.ptrvalue, file)) { /* have it */ if (* ampptr == NULL) /* fill dynamic load */ { * ampptr = (AsnModulePtr) ampanp->data.ptrvalue; * atptr = (* ampptr)->types; /* don't really need avnptr filled in */ } return TRUE; } ampanp = ampanp->next; anp = anp->next; } if (! ProgMon("Load ASN.1 Trees")) return FALSE; if (* ampptr != NULL) /* static load, add to list */ { AsnStoreTree(file, (* ampptr)); return TRUE; /* already loaded */ } if (! FindPath("ncbi", "ncbi", "asnload", name, sizeof (name))) { AsnIoErrorMsg(NULL, 85); return FALSE; } FileBuildPath (name, NULL, file);/* add file to path */ fp = FileOpen(name, "r"); if (fp == NULL) { AsnIoErrorMsg(NULL, 83, (CharPtr) name); return FALSE; } fscanf(fp, "%d %d %d", &numval, &numtype, &nummod); if (numval) avn = (AsnValxNodePtr) MemNew(numval * sizeof(AsnValxNode)); at = (AsnTypePtr) MemNew(numtype * sizeof(AsnType)); amp = (AsnModulePtr) MemNew(nummod * sizeof(AsnModule)); *avnptr = avn; *atptr = at; *ampptr = amp; avncurr = avn; for (i = 0; i < numval; i++) { fscanf(fp, "%d %s %ld %lf %d", &isa, name, &intvalue, &realvalue, &next); avncurr->valueisa = isa; if (*name != '-') avncurr->name = StringSave(name); avncurr->intvalue = (Int4)intvalue; avncurr->realvalue = (FloatHi)realvalue; avncurr->next = (AsnValxNodePtr) PointerDecode((Int2)next, avn, at); avncurr++; } atcurr = at; for (i = 0; i < numtype; i++) { fscanf(fp, "%d %s %d %d %d %d %d %d %d %d %d %d %d", &isa, name, &tagclass, &tagnumber, bools, bools+1, bools+2, bools+3, bools+4, &defaultvalue, &type, &branch, &next); atcurr->isa = isa; if (*name != '-') { atcurr->name = StringSave(name); ptr = atcurr->name; while (*ptr != '\0') { if (*ptr == '!') *ptr = ' '; ptr++; } } atcurr->tagclass = (Uint1)tagclass; atcurr->tagnumber = tagnumber; atcurr->implicit = (Boolean)bools[0]; atcurr->optional = (Boolean)bools[1]; atcurr->hasdefault = (Boolean)bools[2]; atcurr->exported = (Boolean)bools[3]; atcurr->imported = (Boolean)bools[4]; atcurr->defaultvalue = (AsnValxNodePtr)PointerDecode((Int2)defaultvalue, avn, at); atcurr->type = (AsnTypePtr)PointerDecode((Int2)type, avn, at); atcurr->branch = PointerDecode((Int2)branch, avn, at); atcurr->next = (AsnTypePtr)PointerDecode((Int2)next, avn,at); atcurr++; } ampcurr = amp; for (i = 0; i < nummod; i++) { fscanf(fp, "%s %s %d %d", name, fname, &type, &next); if (*name != '-') ampcurr->modulename = StringSave(name); if (*fname != '-') ampcurr->filename = StringSave(fname); ampcurr->types = (AsnTypePtr)PointerDecode((Int2)type, avn, at); if (next != -32000) ampcurr->next = &[next]; ampcurr++; } FileClose(fp); /* store it in list */ AsnStoreTree(file, (* ampptr)); return TRUE; }
/***************************************************************************** * * Boolean AsnTypeValidateOut(aip, atp, dvp) * if not open or closing a SET, SEQ, SETOF, SEQOF, will * put atp in aip->typestack if it validates. * * KNOWN DEFECT: SET should check for 1 of each non-optional element * It does not right now, it only checks that an element is a valid * member of the SET. * *****************************************************************************/ NLM_EXTERN Boolean AsnTypeValidateOut (AsnIoPtr aip, AsnTypePtr atp, DataValPtr dvp) { Int2 isa; AsnTypePtr atp2, parent_type, base_type, curr_type; Boolean foundit; AsnValxNodePtr avnp; if ((aip == NULL) || (atp == NULL)) return FALSE; curr_type = aip->typestack[aip->type_indent].type; base_type = AsnFindBaseType(atp); if (base_type == NULL) { AsnIoErrorMsg(aip, 10, AsnErrGetTypeName(atp->name), "AsnTypeValidateOut"); return FALSE; } isa = base_type->type->isa; if (((isa == SEQ_TYPE) || (isa == SET_TYPE) || (isa == SEQOF_TYPE) || (isa == SETOF_TYPE)) && (dvp->intvalue == END_STRUCT)) { 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, 7, AsnErrGetTypeName(atp2->name), AsnErrGetTypeName(atp->name)); return FALSE; } atp2 = atp2->next; } break; default: break; } return TRUE; } if (aip->type_indent) /* part of a larger struct */ { foundit = FALSE; if (aip->type_indent < 1) return FALSE; parent_type = aip->typestack[aip->type_indent - 1].type; base_type = AsnFindBaseType(parent_type); if (base_type == NULL) return FALSE; isa = base_type->type->isa; atp2 = (AsnTypePtr) base_type->branch; while (atp2 != NULL) { if (atp2 == atp) { foundit = TRUE; break; } atp2 = atp2->next; } if (! foundit) { atp2 = AsnFindBaseType(atp); AsnIoErrorMsg(aip, 22, AsnErrGetTypeName(atp->name), AsnErrGetTypeName(atp2->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } switch (isa) { case SETOF_TYPE: /* just has to be right type */ case SEQOF_TYPE: break; case CHOICE_TYPE: /* can only have one value */ if (curr_type != NULL) { AsnIoErrorMsg(aip, 23, AsnErrGetTypeName(parent_type->name), AsnErrGetTypeName(atp->name)); return FALSE; } break; case SET_TYPE: /* SET should check for 1 of each */ /* non-optional element, but doesn't */ if (curr_type == atp) { AsnIoErrorMsg(aip, 24, AsnErrGetTypeName(atp->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } break; case SEQ_TYPE: if (curr_type == atp) { AsnIoErrorMsg(aip, 24, AsnErrGetTypeName(atp->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } /* check preceeding elements */ if (curr_type != NULL) { atp2 = (AsnTypePtr) base_type->branch; while (atp2 != curr_type->next) { if (atp == atp2) { AsnIoErrorMsg(aip, 6, AsnErrGetTypeName(atp->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } atp2 = atp2->next; } } else atp2 = (AsnTypePtr) base_type->branch; while ((atp2 != NULL) && (atp != atp2)) { if (! (atp2->optional || atp2->hasdefault)) { /* skipped a non-optional element */ AsnIoErrorMsg(aip, 7, AsnErrGetTypeName(atp2->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } atp2 = atp2->next; } if (atp2 == NULL) /* element out of order */ { AsnIoErrorMsg(aip, 6, AsnErrGetTypeName(atp->name), AsnErrGetTypeName(parent_type->name)); return FALSE; } break; default: AsnIoErrorMsg(aip, 25, AsnErrGetTypeName(parent_type->name), parent_type->isa); return FALSE; } base_type = AsnFindBaseType(atp); isa = base_type->type->isa; } if (ISA_STRINGTYPE(isa)) isa = GENERALSTRING_TYPE; /******************* maintain typestack ****************/ switch (isa) /* set aip->typestack for non-struct types */ { /* this is done for them in AsnTypeSetIndent() */ case SEQ_TYPE: case SET_TYPE: case SEQOF_TYPE: case SETOF_TYPE: case CHOICE_TYPE: default: /* terminal value */ aip->typestack[aip->type_indent].type = atp; break; } switch (isa) /* check ranges and values */ { case ENUM_TYPE: avnp = (AsnValxNodePtr) base_type->branch; while (avnp != NULL) { if (avnp->intvalue == dvp->intvalue) return TRUE; avnp = avnp->next; } AsnIoErrorMsg(aip, 12, dvp->intvalue, AsnErrGetTypeName(atp->name)); return FALSE; default : break; } return TRUE; }
/***************************************************************************** * * Int2 AsnLexTWord(aip) * reads words, punctuation, and asn keywords with 2 parts * returns tokens defined at top * *****************************************************************************/ NLM_EXTERN Int2 AsnLexTWord (AsnIoPtr aip) { register CharPtr pos; register int len; Int1 state; Int2 token, asntype, linepos; int done; Boolean first = FALSE, hitnewline = FALSE; CharPtr commentptr; if (! aip->bytes) /* no data loaded */ { hitnewline = TRUE; first = TRUE; AsnIoGets(aip); } linepos = aip->linepos; pos = aip->linebuf + linepos; state = aip->state; len = 0; token = -1; while (*pos == '\n' || *pos == '\r') /* skip empty lines */ { hitnewline = TRUE; pos = AsnIoGets(aip); if (pos == NULL) return EOF_TOKEN; } if (state == IN_STRING_STATE) { aip->word = pos; if (* pos == '\"') /* end of string */ { token = END_STRING; pos++; state = 0; /* reset state */ } else { token = IN_STRING; while ((* pos != '\"') && (* pos != '\n') && (* pos != '\r')) { pos++; len++; } if ((*pos != '\n') && (*pos != '\r') && (* (pos + 1) == '\"')) /* internal quote */ { len++; /* include in previous string */ pos += 2; /* point to rest of string */ } } } else if (state == IN_BITHEX_STATE) { aip->word = pos; if (*pos == '\'') /* end of binhex */ { state = 0; /* set to normal */ pos++; /* move past quote */ while (IS_WHITESP(*pos)) pos++; if (* pos == 'H') token = OCTETS; else if (* pos == 'B') token = ASNBITS; else { AsnIoErrorMsg(aip, 58, aip->linenumber); token = ERROR_TOKEN; } } else { token = IN_BITHEX; while ((* pos != '\'') && (* pos != '\n') && (* pos != '\r')) { pos++; len++; } } } else /* normal scanning */ { done = 0; while (! done) { while (* pos <= ' ') /* skip leading white space */ { if (*pos == '\n' || *pos == '\r') { hitnewline = TRUE; pos = AsnIoGets(aip); if (pos == NULL) return EOF_TOKEN; } else pos++; } done = 1; while (done && (*pos == '-') && (*(pos+1) == '-')) /* skip comments */ { pos += 2; if (first) /* could be revision */ { first = FALSE; if (StrMatch(asnwords[57], pos, 10)) /* $Revision: */ { token = REVISION_TOKEN; pos += 10; while (IS_WHITESP(*pos)) pos++; aip->word = pos; while (IS_DIGIT(*pos)) /* eg. 1.2 */ { len++; pos++; } if (*pos == '.') /* take after . if present */ { pos++; len++; while (IS_DIGIT(*pos)) { len++; pos++; } } } } commentptr = pos; done = 0; while (! done) /* skip to end of comment */ { if ((*pos == '-') && (*(pos +1) == '-')) { if (token != REVISION_TOKEN) { AsnLexTAddComment(commentptr, pos, aip); if ((! hitnewline) && (aip->token != COMMENT_TOKEN)) token = COMMENT_TOKEN; } pos += 2; done = 1; } else if (*pos == '\n' || *pos == '\r') { if (token != REVISION_TOKEN) { AsnLexTAddComment(commentptr, pos, aip); if ((! hitnewline) && (aip->token != COMMENT_TOKEN)) token = COMMENT_TOKEN; } done = 1; } else pos++; } if ((token == REVISION_TOKEN) || (token == COMMENT_TOKEN)) { aip->linepos = pos - aip->linebuf; aip->state = state; aip->wordlen = len; aip->token = token; return token; } if (*pos <= ' ') done = 0; else done = 1; } } aip->word = pos; if (* pos == '\"') { token = START_STRING; state = IN_STRING_STATE; } else if (* pos == '\'') { token = START_BITHEX; state = IN_BITHEX_STATE; } else if (* pos == ',') token = COMMA; else if (* pos == '{') token = START_STRUCT; else if (* pos == '}') token = END_STRUCT; else if (* pos == '[') token = START_TAG; else if (* pos == ']') token = END_TAG; else if (* pos == '(') token = OPEN_PAREN; else if (* pos == ')') token = CLOSE_PAREN; else if (* pos == ';') token = SEMI_COLON; else if (* pos == ':') { if ((*(pos + 1) == ':') && (*(pos + 2) == '=')) { token = ISDEF; pos += 2; len = 3; } else { AsnIoErrorMsg(aip, 59, *pos, aip->linenumber); token = ERROR_TOKEN; } } else if (IS_UPPER(*pos)) /* a reference or keyword */ { token = REF; while ((IS_ALPHANUM(*pos)) || (*pos == '-')) { pos++; len++; } aip->wordlen = len; asntype = AsnLexTMatchToken(aip); /* check types */ if (asntype) /* did it match ? */ { if ((asntype > 27) && (asntype < 57)) /* not a primitive type */ { token = asntype + 400; /* make a keyword type */ if (asntype == COMPS_TOKEN) /* COMPONENTS OF */ { if ((*(pos + 1) == 'O') && (*(pos + 2) == 'F') && (IS_WHITESP(*(pos+3)))) { pos += 3; /* move past OF */ len += 3; } else AsnIoErrorMsg(aip, 89, aip->linenumber); } } else if (asntype == 57) /* StringStore */ token = STRSTORE_TYPE; else if (asntype == 59) /* BitInt */ token = BIGINT_TYPE; else { switch (asntype) { case 3: /* BIT */ case 4: /* OCTET */ if (! StrMatch(asnwords[11], (pos+1), 6)) AsnIoErrorMsg(aip, 90, aip->linenumber); pos += 7; /* move past STRING */ len += 7; break; case 11: /* SEQUENCE */ case 13: /* SET */ if ((*(pos + 1) == 'O') && (*(pos + 2) == 'F')) { asntype++; /* SET or SEQ OF */ pos += 3; len += 3; if (! IS_WHITESP(*pos)) AsnIoErrorMsg(aip, 91, aip->linenumber); } break; case 6: /* OBJECT */ if ((! StrMatch(asnwords[55], (pos+1), 10))) /* IDENTIFIER */ AsnIoErrorMsg(aip, 92, aip->linenumber); pos += 11; len += 11; break; default: break; } token = asntype + 300; /* change to point at type */ } } pos--; /* move back for increment at end */ len--; } else if (IS_LOWER(*pos)) /* an identifier or valuereference */ { token = IDENT; while ((IS_ALPHANUM(*pos)) || (*pos == '-')) { pos++; len++; } pos--; /* move back for increment at end */ len--; } else if ((IS_DIGIT(*pos)) || ((*pos == '-') && (IS_DIGIT(*(pos+1))))) { token = NUMBER; if (*pos == '-') { pos++; len++; } while (IS_DIGIT(*pos)) { pos++; len++; } pos--; /* move back for increment at end */ len--; } else { AsnIoErrorMsg(aip, 59, *pos, aip->linenumber); token = ERROR_TOKEN; } len++; pos++; /* move over last symbol */ } aip->linepos = pos - aip->linebuf; aip->state = state; aip->wordlen = len; aip->token = token; return token; }
/***************************************************************************** * * 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; }
/***************************************************************************** * * 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; }