NLM_EXTERN void print_label(FILE *fp, CharPtr label, Int4 pos, Uint1 strand, Boolean extra_space) { Int4 len; Char symbol; Char temp[100]; len = 0; if(label) { len = StringLen(label); fprintf(fp, "%s", label); } for(; len<B_SPACE; ++len) fprintf(fp, " "); symbol = ' '; if(strand == Seq_strand_plus) symbol = '>'; if(strand == Seq_strand_minus) symbol = '<'; fprintf(fp, " %c ", symbol); len = 0; if(pos != -1) { sprintf(temp, "%ld", (long) pos); len = StringLen(temp); fprintf(fp, "%s", temp); } if(extra_space) /*for partial codon*/ ++len; for(; len <POS_SPACE; ++len) fprintf(fp, " "); }
int64_t decode(void *buffer, size_t size, int64_t sum) { unsigned int i; C(table_t) foobarcontainer; FooBar(vec_t) list; FooBar(table_t) foobar; Bar(struct_t) bar; Foo(struct_t) foo; foobarcontainer = C(as_root(buffer)); sum += C(initialized(foobarcontainer)); sum += StringLen(C(location(foobarcontainer))); sum += C(fruit(foobarcontainer)); list = C(list(foobarcontainer)); for (i = 0; i < FooBar(vec_len(list)); ++i) { foobar = FooBar(vec_at(list, i)); sum += StringLen(FooBar(name(foobar))); sum += FooBar(postfix(foobar)); sum += (int64_t)FooBar(rating(foobar)); bar = FooBar(sibling(foobar)); sum += (int64_t)Bar(ratio(bar)); sum += Bar(size(bar)); sum += Bar(time(bar)); foo = Bar(parent(bar)); sum += Foo(count(foo)); sum += Foo(id(foo)); sum += Foo(length(foo)); sum += Foo(prefix(foo)); } return sum + 2 * sum; }
/***************************************************************************** * * StdAuthListNamesPrint(dvp) * prints just Auth-list.names to a string * *****************************************************************************/ NLM_EXTERN CharPtr StdAuthListNamesPrint(DataValPtr dvp) { AuthListPtr alp; Boolean first = TRUE; ValNodePtr vnp; PersonIdPtr pip; AuthorPtr ap; ByteStorePtr bsp; CharPtr str; Char buf[60]; if (dvp == NULL) return NULL; alp = (AuthListPtr)(dvp->ptrvalue); if (alp == NULL) return NULL; bsp = BSNew(80); for (vnp = alp->names; vnp != NULL; vnp = vnp->next) { if (! first) /* separators for names after first one */ { if (vnp->next != NULL) BSPutByte(bsp, (Int2)','); else { BSPutByte(bsp, (Int2)' '); BSPutByte(bsp, (Int2)'&'); } BSPutByte(bsp, (Int2)' '); } first = FALSE; if (alp->choice == 3 || alp->choice == 2) /* ml or str */ { BSWrite(bsp, vnp->data.ptrvalue, (Int4)(StringLen((CharPtr)(vnp->data.ptrvalue)))); } else if (alp->choice == 1) /* std */ { ap = (AuthorPtr) (vnp->data.ptrvalue); if (ap != NULL) { pip = ap->name; PersonIdPrint(pip, buf); BSWrite(bsp, buf, (Int4)StringLen(buf)); } else BSPutByte(bsp, (Int2)'?'); } } str = BSMerge(bsp, NULL); BSFree(bsp); return str; }
static Boolean SaveSetsInOneSelectedSet (GatherObjectPtr gop) { SetSavePtr ssp; SelStructPtr sel; BioseqSetPtr bssp; CharPtr filename, file_fmt = "%s_%d.sqn"; SeqEntryPtr sep; AsnIoPtr aip; #ifdef WIN_MAC FILE *fp; #endif if (gop == NULL || gop->dataptr == NULL || gop->itemtype != OBJ_BIOSEQSET) return TRUE; ssp = (SetSavePtr) gop->userdata; if (ssp == NULL || StringHasNoText (ssp->file_base)) return TRUE; sel = ssp->sel; while (sel != NULL && (sel->entityID != gop->entityID || sel->itemtype != gop->itemtype || sel->itemID != gop->itemID)) { sel = sel->next; } if (sel == NULL) return TRUE; bssp = gop->dataptr; filename = (CharPtr) MemNew (sizeof (Char) + (StringLen (ssp->file_base) + StringLen (file_fmt) + 15)); for (sep = bssp->seq_set; sep != NULL; sep = sep->next) { sprintf (filename, file_fmt, ssp->file_base, ssp->file_num); ssp->file_num++; #ifdef WIN_MAC fp = FileOpen (filename, "r"); if (fp != NULL) { FileClose (fp); } else { FileCreate (filename, "TEXT", "ttxt"); } #endif aip = AsnIoOpen(filename, "w"); SeqEntryAsnWrite (sep, aip, NULL); AsnIoClose (aip); } filename = MemFree (filename); return TRUE; }
static Boolean UpdateContigReadId (TContigReadPtr read, SeqIdReplaceListPtr pair_list, Boolean no_lookup, Boolean is_srr, char *has_errors) { SeqIdPairPtr pair; SeqIdPtr sip_find; Char id_buf[255]; Boolean rval = TRUE; if (read == NULL || StringHasNoText (read->read_id)) { rval = FALSE; } else { sip_find = MakeSeqID (read->read_id); pair = FindReplacementInSeqIdReplaceList (sip_find, pair_list); if (pair != NULL && (no_lookup || OkToReplaceId (pair, read->read_seq, has_errors))) { if (pair->is_complement) { if (read->is_complement) { read->is_complement = FALSE; } else { read->is_complement = TRUE; } } if (pair->ti > 0) { read->ti = pair->ti; } else { if (pair->sip_replace->choice == SEQID_LOCAL) { SeqIdWrite (pair->sip_replace, id_buf, PRINTID_REPORT, sizeof (id_buf) - 1); } else { SeqIdWrite (pair->sip_replace, id_buf, PRINTID_FASTA_LONG, sizeof (id_buf) - 1); } if (is_srr) { if (read->srr != NULL) { free (read->srr); } read->srr = malloc (sizeof (Char) * (StringLen (id_buf) + 1)); sprintf (read->srr, "%s", id_buf); free (read->read_id); read->read_id = NULL; } else { free (read->read_id); read->read_id = malloc (sizeof (Char) * (StringLen (id_buf) + 1)); sprintf (read->read_id, "%s", id_buf); } } read->local = FALSE; } sip_find = SeqIdFree (sip_find); } return rval; }
/* Pops top StringStack item from StringStack */ CharPtr SLRI_SSPop(SLRI_SStackPtr ssp) { CharPtr string = NULL; SLRI_SStackItemPtr ssipNewTop = NULL; if (ssp == NULL) { ErrPostEx(SEV_ERROR, 0, 0, "SLRI_SSPop: stack pointer is NULL"); return(NULL); } if (SLRI_SSIsEmpty(ssp)) { ErrPostEx(SEV_ERROR, 0, 0, "SLRI_SSPop: stack is empty"); return(NULL); } ssipNewTop = ssp->top->prev; string = StringSave(ssp->top->string); ssp->top = MemFree(ssp->top); ssp->top = ssipNewTop; ssp->totalStackSize -= StringLen(string); ssp->totalNumItems--; /* If last item on stack, set bottom pointer to top */ if (ssp->top == NULL) { ssp->bottom = ssp->top; } return(string); }
/* Pushes a StringStack item onto StringStack */ Int4 SLRI_SSPush(SLRI_SStackPtr ssp, CharPtr string) { SLRI_SStackItemPtr newItem = NULL; if (ssp == NULL) { ErrPostEx(SEV_ERROR, 0, 0, "SLRI_SSPush: stack pointer is NULL"); return(-1); } newItem = MemNew(sizeof(SLRI_SStackItem)); newItem->string = string; newItem->prev = ssp->top; newItem->next = NULL; if (ssp->top != NULL) { ssp->top->next = newItem; } ssp->top = newItem; ssp->totalStackSize += StringLen(newItem->string); ssp->totalNumItems++; /* If first item, set bottom pointer to top */ if (ssp->bottom == NULL) { ssp->bottom = ssp->top; } return(0); }
static Boolean s_MightBeCorruptSequence (Int4 seqCharCount, CharPtr seqString, AliConfigInfoPtr configPtr) { Int4 i; Int4 badCharCount; Int4 seqStrLen; FloatLo percentGood; seqStrLen = StringLen(seqString); badCharCount = 0; for (i = 0; i < seqStrLen; i++) { if (IsSequenceChar(seqString[i], configPtr->gapChar, configPtr->missingChar, configPtr->unalignedChar)) seqCharCount++; else badCharCount++; } percentGood = (FloatLo) seqCharCount / ((FloatLo) seqCharCount + (FloatLo) badCharCount); if ((percentGood * 100) >= configPtr->corruptSeqThreshold) return TRUE; else return FALSE; }
NLM_EXTERN Boolean SendTextToFile (FILE *f, CharPtr text, ParPtr parFmt, ColPtr colFmt) { Uint2 cnt; Uint2 cntr; Boolean rsult; Int2 start; TablePtr tptr; rsult = TRUE; start = 0; cntr = StringLen (text); cnt = MIN (cntr, 64000); cnt = SkipPastNewLine (text + start, cnt); while (cnt > 0) { tptr = TableSegment (text + start, cnt, parFmt, colFmt); if (! SaveTableToFile (tptr, f)) { rsult = FALSE; } FreeTable (tptr); start += cnt; cntr -= cnt; cnt = MIN (cntr, 64000); cnt = SkipPastNewLine (text + start, cnt); } return rsult; }
Int2 Main (void) { Char buf[256] = { '\0' }; /* Used below for name and version. */ Int2 status = 0; /* return value of function. */ StringCpy(buf, "bl2seq "); StringNCat(buf, BlastGetVersionNumber(), sizeof(buf)-StringLen(buf)-1); if (! GetArgs (buf, NUMARG, myargs)) { return (1); } UseLocalAsnloadDataAndErrMsg (); if (! SeqEntryLoad()) return 1; ErrSetMessageLevel(SEV_WARNING); if (myargs[ARG_FORCE_OLD].intvalue != 0) status = Main_old(); else status = Main_new(); FreeArgs(NUMARG, myargs); return status; }
/*数据结构:链表,含头节点,每个节点为AnalysisNode,其中treeroot为一颗分析树,分析一类词法元素*/ AnalysisNodePtr AnalysisListCreate(char* lexString){ char* lexicalDeclare = (char*)malloc(sizeof(char)*MAXLEXDECLEN); char* lexicalDef = (char*)malloc(sizeof(char)*MAXLEXDEFLEN); int lexicalDeclareLen = 0; int pos = 0; AnalysisNodePtr newAnalysisTree; AnalysisNodeBegin = (AnalysisNodePtr)malloc(sizeof(AnalysisNode)); AnalysisNodeBegin->next = NULL; AnalysisNodeBegin->treeRoot = NULL; AnalysisNodeBegin->nodeName = "begin"; while (LexStringSplit(lexString,&pos,lexicalDeclare,lexicalDef)==true){ newAnalysisTree = (AnalysisNodePtr)malloc(sizeof(AnalysisNode)); lexicalDeclareLen = StringLen(lexicalDeclare); newAnalysisTree->nodeName = (char*)malloc(sizeof(char)*lexicalDeclareLen); StringCopy(newAnalysisTree->nodeName, lexicalDeclare); newAnalysisTree->treeRoot = AnalysisTreeCreate(lexicalDef); //头插法,复杂分析树放在前,识别时从复杂部分开始; newAnalysisTree->next = AnalysisNodeBegin->next; AnalysisNodeBegin->next = newAnalysisTree; } return AnalysisNodeBegin; }
VOID LoadFile(LPTSTR File) { TCHAR Command[2*MAX_PATH], fName[MAX_PATH], fExt[MAX_PATH], Buffer[MAX_PATH]; //Move the current directory SetWorkingDirToFileLoc(File); // get file name and extension _tsplitpath (File, NULL, NULL, fName, fExt); wsprintf(Buffer,TEXT("%s%s"),fName,fExt); wsprintf(Command, TEXT(":load %s"), ExpandFileName(Buffer)); AddMruFile(File); RtfWindowSetCommand(TEXT(":load ")); StartOfInput += 6; WinGHCiHyperlink(ExpandFileName(Buffer)); StartOfInput += StringLen(ExpandFileName(Buffer)); RtfWindowStartNextOutput(); AddHistory(Command); SendToGHCiStdinLn(Command); Running = TRUE; EnableButtons(); PrintGHCiOutputIfAvailable(hChildStderrRd, ErrorColor); PrintGHCiOutput(hChildStdoutRd, ForegroundColor); Running = FALSE; EnableButtons(); }
Int2 Nlm_Main(void) { Boolean use_new_engine=FALSE; char buf[256] = { '\0' }; StringCpy(buf, "mgblast "); StringNCat(buf, BlastGetVersionNumber(), sizeof(buf)-StringLen(buf)-1); if (! GetArgs (buf, NUMARG, myargs)) return (1); UseLocalAsnloadDataAndErrMsg (); if (! SeqEntryLoad()) return 1; ErrSetMessageLevel(SEV_WARNING); /* if (myargs[ARG_FORCE_OLD].intvalue == 0 && myargs[ARG_OUTTYPE].intvalue > 1 && myargs[ARG_GILIST].strvalue == NULL) use_new_engine = readdb_use_new_blast(myargs[ARG_DB].strvalue); if (myargs[ARG_MASKEDQUERY].strvalue) use_new_engine = FALSE; */ /*if (use_new_engine) return Main_new(); else */ return Main_old(); }
static void StringFit(char *s,int w) { if(StringLen(s) > w) { int i; w = w / 2; for(i = 0; i < w; i++) { s[i + w] = s[StringLen(s) - w + i]; } s[w + w] = 0; } }
static CharPtr TagStringFromFieldRule (FieldRulePtr rule) { Int4 len; CharPtr fmt = "%s\t%s\t%d\n"; CharPtr str; if (rule == NULL) { return NULL; } len = StringLen (fmt) + StringLen (rule->field_name) + StringLen (rule->match_expression); str = (CharPtr) MemNew (sizeof (Char) * len); sprintf (str, fmt, rule->field_name == NULL ? "" : rule->field_name, rule->match_expression == NULL ? "" : rule->match_expression, rule->required ? 1 : 0); return str; }
static Boolean LIBCALLBACK ExtractCodingRegions (BioseqPtr bsp, SeqMgrBioseqContextPtr bcontext) { Char buf [255]; SeqFeatPtr cds; SeqMgrFeatContext fcontext; FILE *fp; SeqPortPtr spp; if (! ISA_na (bsp->mol)) return TRUE; fp = (FILE *) bcontext->userdata; BioseqLock (bsp); cds = SeqMgrGetNextFeature (bsp, NULL, SEQFEAT_CDREGION, 0, &fcontext); while (cds != NULL) { /* spp = FastaSeqPort (bsp, TRUE, FALSE, Seq_code_iupacna); */ spp = SeqPortNewByLoc (cds->location, Seq_code_iupacna); if (spp != NULL) { /* if (FastaId (bsp, buf, sizeof (buf) - 1)) { FastaFileFunc (bsp, FASTA_ID, buf, StringLen (buf), (Pointer) fp); } if (CreateDefLine (NULL, bsp, buf, sizeof (buf) - 1, 0, NULL, NULL)) { FastaFileFunc (bsp, FASTA_DEFLINE, buf, StringLen (buf), (Pointer) fp); } */ SeqLocLabel (cds->location, buf, sizeof (buf), OM_LABEL_CONTENT); FastaFileFunc (bsp, FASTA_ID, buf, StringLen (buf), (Pointer) fp); FastaFileFunc (bsp, FASTA_DEFLINE, fcontext.label, StringLen (fcontext.label), (Pointer) fp); while (FastaSeqLine (spp, buf, 80, TRUE)) { FastaFileFunc (bsp, FASTA_SEQLINE, buf, StringLen (buf), (Pointer) fp); } FastaFileFunc (bsp, FASTA_EOS, buf, StringLen (buf), (Pointer) fp); SeqPortFree (spp); } cds = SeqMgrGetNextFeature (bsp, cds, SEQFEAT_CDREGION, 0, &fcontext); } BioseqUnlock (bsp); return TRUE; }
/***************************************************************************** * * PersonIdPrint(pip, buf) * *****************************************************************************/ NLM_EXTERN CharPtr PersonIdPrint(PersonIdPtr pip, CharPtr buf) { CharPtr tmp; NameStdPtr nsp; if (buf == NULL) return NULL; tmp = buf; *tmp = '?'; *(tmp + 1) = '\0'; if (pip == NULL) return buf; if (pip->choice == 2) /* std */ { nsp = (NameStdPtr) (pip->data); if (nsp != NULL) { if (nsp->names [3] != NULL) /* full name */ tmp = StringMove(tmp, nsp->names [3]); else if (nsp->names[0] != NULL) /* make from parts */ { if (nsp->names [1] != NULL && nsp->names [2] != NULL) { tmp = StringMove(tmp, nsp->names [1]); /* first */ *tmp = ' '; tmp++; *tmp='\0'; tmp = StringMove(tmp, nsp->names [2]); /* middle */ *tmp = ' '; tmp++; *tmp='\0'; } else if ((nsp->names [4] != NULL) && (nsp->names [0] != NULL) && (StringLen(nsp->names[4]) < 10)) { tmp = StringMove(tmp, nsp->names [4]); /* initials */ *tmp = ' '; tmp++; *tmp='\0'; } else if (nsp->names [1] != NULL) { tmp = StringMove(tmp, nsp->names [1]); *tmp = ' '; tmp++; *tmp='\0'; } tmp = StringMove(tmp, nsp->names [0]); /* last */ if (nsp->names[5] != NULL) /* suffix */ { *tmp = ' '; tmp++; *tmp='\0'; tmp = StringMove(tmp, nsp->names[5]); } } } } else if (pip->choice == 3 || pip->choice == 4) /* ml or str */ StringMove(tmp, (CharPtr)(pip->data)); return buf; }
static void Cn3D_KinEnableProc(TexT t) { Char str[32]; GetTitle(Cn3D_tKinSave, str, sizeof(str)); if (StringLen(str) == 0) { Disable(Cn3D_bKinOk); } else { Enable(Cn3D_bKinOk); } return; }
static void Dumb_MonStrValue (MonitorPtr pMon) { char *buf = (char *) pMon->extra; size_t len0 = (int)pMon->num1; size_t len1 = MIN(StringLen(pMon->strValue),len0); size_t diff = (len0-len1)/2; Nlm_MemFill(&buf[3],' ',len0+2); Nlm_MemCopy(&buf[4+diff],pMon->strValue,len1); fprintf(stderr,"\r%s",buf); fflush(stderr); }
NLM_EXTERN CONN QUERY_OpenServiceQueryEx ( const char* service, const char* parameters, Nlm_Uint4 timeoutsec, const char* arguments ) { CONN conn; CONNECTOR connector; SConnNetInfo* net_info; size_t n_written; EIO_Status status; /* fill in connection info fields and create the connection */ net_info = ConnNetInfo_Create (service); ASSERT ( net_info ); /* let the user agent be set with a program name */ x_SetupUserHeader (net_info, NULL, eMIME_T_Unknown, eMIME_Unknown, eENCOD_None); if (timeoutsec == (Nlm_Uint4)(-1L)) { net_info->timeout = kInfiniteTimeout; } else if ( timeoutsec ) { net_info->tmo.sec = timeoutsec; net_info->tmo.usec = timeoutsec; net_info->timeout = &net_info->tmo; } ConnNetInfo_PostOverrideArg (net_info, arguments, 0); connector = SERVICE_CreateConnectorEx (service, fSERV_Any, net_info, 0); ConnNetInfo_Destroy (net_info); if (connector == NULL) { ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed in SERVICE_CreateConnectorEx"); conn = NULL; } else if ((status = CONN_Create (connector, &conn)) != eIO_Success) { ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed in CONN_Create:" " %s", IO_StatusStr (status)); ASSERT (conn == NULL); } else if (StringDoesHaveText (parameters)) { status = CONN_Write (conn, parameters, StringLen (parameters), &n_written, eIO_WritePersist); if (status != eIO_Success) { ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed to write service parameters in CONN_Write: %s", IO_StatusStr (status)); CONN_Close (conn); conn = NULL; } } return conn; }
/************************************************************************* *** * gb_id_make(): make the Seq-id for Genbank with tsip->name = name * tsip->acc. * ************************************************************************* ***/ NLM_EXTERN SeqIdPtr gb_id_make(CharPtr name, CharPtr acc) { SeqIdPtr new_id; TextSeqIdPtr tsip; new_id= (SeqIdPtr)ValNodeNew(NULL); new_id->choice = SEQID_GENBANK; tsip = TextSeqIdNew(); if(name) { if(StringLen(name) >3 && IS_ALPHA(name[0])) tsip->name = StringSave(name); } if(acc) { if(StringLen(acc) >3 && IS_ALPHA(acc[0])) tsip->accession = StringSave(acc); } new_id->data.ptrvalue = tsip; return new_id; }
CharPtr NextUniqueChainName(PMSD pmsd) { /* Must return a new letter for the added chain name */ PDNMM pdnmmHere; PMMD pmmdHere; char *ptr,*chainptr; CharPtr pcChainName=NULL; CharPtr newChainName=NULL; char Alphabet[]="123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; Int2 i=0; chainptr=Alphabet; pdnmmHere=pmsd->pdnmmHead; while(pdnmmHere != NULL){ /*printf("pdnmmHere is %d\n",pdnmmHere->choice);*/ pmmdHere=(PMMD)pdnmmHere->data.ptrvalue; if (pmmdHere==NULL) break; pcChainName=pmmdHere->pcMolName; if (pcChainName==NULL) break; Misc_TrimSpacesAroundString(pcChainName); /* printf("pcChainame here is %s\n",pcChainName); */ if (StringLen(pcChainName)==1 ) { ptr=Alphabet; while (*ptr != '\0'){ if (*ptr == pcChainName[0]) { *ptr = '0'; /* marks the ones in use with 0 */ break; } ptr++; } } pdnmmHere=pdnmmHere->next; } newChainName=(CharPtr)MemNew(2*sizeof(Char)); while(*chainptr !='\0'){ if(*chainptr != '0') { newChainName[0] = *chainptr; break; } chainptr++; } return newChainName; /* See original code ... beware of non biopolymer names */ }
static Boolean LoadObjPrtFromLocalString (CharPtr localStr) { Boolean retval = FALSE; #ifndef WIN16 AsnIoMemPtr aimp; aimp = AsnIoMemOpen ("r", (BytePtr) localStr, (Int4) StringLen (localStr)); if (aimp == NULL || aimp->aip == NULL) return FALSE; retval = PrintTemplateSetAsnRead (aimp->aip); AsnIoMemClose (aimp); #endif return retval; }
static void /*FCN*/OnText16 ( TexT t ){ Char curVal[20]; GetTitle ( t, &(curVal[0]), 20 ); curVal[19] = 0; if ( StringLen ( &(curVal[0]) ) > 16 ){ Nlm_Beep(); curVal[17] = 0; SetTitle ( t, &(curVal[0]) ); } }
VOID WinGHCiHyperlink(LPCTSTR msg) { CHARFORMAT2 cf2; FlushBuffer(TRUE); cf2.cbSize = sizeof(cf2); cf2.dwMask = CFM_LINK; cf2.dwEffects = CFE_LINK; SendMessage(hWndRtf, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) &cf2); SendMessage(hWndRtf, EM_REPLACESEL, FALSE, (LPARAM) msg); StartOfInput += StringLen(msg); cf2.dwEffects = 0; SendMessage(hWndRtf, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM) &cf2); }
// all strings are null terminated. Assumes enough space in Result VOID StringReplaceAllOccurrences(LPTSTR Str, LPTSTR ToReplace, LPTSTR Replacement, LPTSTR Result) { LPTSTR p; TCHAR svChar; INT ToReplaceLen = StringLen(ToReplace); INT ReplacementLen = StringLen(Replacement); Result[0] = TEXT('\0'); for(;;) { p = StringSearchString(Str,ToReplace); if (p==NULL) { StringCat(Result,Str); break; } svChar = *p; *p=TEXT('\0'); StringCat(Result,Str); *p=svChar; StringCat(Result,Replacement); Str = (p+ToReplaceLen); } }
// need to copy from s to Buf VOID AddToBufferExt(LPCTSTR s, INT numChars) { UpdateFormat(); if (InEscBuf) { for (; numChars>0; s++, numChars--) { if (*s == TEXT('m')) { Format f = NowFormat; if (ParseEscapeCode(&f)) { FormatChanged = TRUE; NowFormat = f; } InEscBuf = FALSE; AddToBufferExt(s+1,numChars-1); return; } else if ((*s >= TEXT('0') && *s <= TEXT('9')) || (*s == TEXT(';')) || (*s == TEXT('['))) { EscBuf[EscBufPos++] = *s; EscBufPos = min(EscBufPos, MAX_ESC_BUFSIZE); } else { InEscBuf = FALSE; AddToBufferExt(EscBuf,StringLen(EscBuf)); break; } } } for (; numChars>0; s++, numChars--) { if (*s == TEXT('\b')) { if (BufPos == 0) { OutputPos--; } else BufPos--; } else if (*s == TEXT('\07')) { Beep( 750, 150 ); } else if (*s == TEXT('\033')) { InEscBuf = TRUE; EscBufPos = 0; AddToBufferExt(s+1,numChars-1); return; } else { if (BufLen >= BufSize) FlushBuffer(TRUE); Buf[BufPos++] = *s; BufLen = max(BufLen, BufPos); } } }
static Uint4 HashPDBCode(CharPtr pcPdb) { Uint4 iPdbhash; Uint4 c1, c2, c3, c4; if (!pcPdb) return 0; if (StringLen(pcPdb) != 4) return 0; c1 = pcPdb[3]; c2 = pcPdb[2]; c3 = pcPdb[1]; c4 = pcPdb[0]; iPdbhash = c1 + (c2 << 8) + (c3 << 16) + (c4 << 24); return iPdbhash; }
static Boolean PvtStrToLong (CharPtr str, Int4Ptr longval) { Char ch; Int2 i; Int2 len; Char local [64]; Boolean nodigits; Boolean rsult; long int val; rsult = FALSE; if (longval != NULL) { *longval = (Int4) 0; } len = (Int2) StringLen (str); if (len != 0) { rsult = TRUE; nodigits = TRUE; for (i = 0; i < len; i++) { ch = str [i]; if (ch == ' ' || ch == '+' || ch == '-') { } else if (ch < '0' || ch > '9') { rsult = FALSE; } else { nodigits = FALSE; } } if (nodigits) { rsult = FALSE; } if (rsult && longval != NULL) { StringNCpy_0 (local, str, sizeof (local)); if (sscanf (local, "%ld", &val) == 1) { *longval = val; } } } return rsult; }
static void DoThesis (PubdescPtr pdp, Pointer userdata) { CitBookPtr cbp; Char ch; ScanDataPtr sdp; CharPtr title, tmp; ValNodePtr ttl, vnp; if (pdp == NULL) return; for (vnp = pdp->pub; vnp != NULL; vnp = vnp->next) { if (vnp->choice == PUB_Man) { cbp = (CitBookPtr) vnp->data.ptrvalue; if (cbp != NULL) { ttl = cbp->title; if (ttl != NULL) { title = (CharPtr) ttl->data.ptrvalue; if (! StringHasNoText (title)) { if (StringLen (title) > 3) { ch = *title; if (IS_LOWER (ch)) { tmp = title; ch = *tmp; while (ch != '\0' && (! (IS_WHITESP (ch)))) { tmp++; ch = *tmp; } *tmp = '\0'; sdp = (ScanDataPtr) userdata; RecordThesis (sdp, title); } } } } } } } }