static bool _StringHas(const String *self, const char *buf, String *res) { String dummy; size_t len = 0; assert(self && buf); if (res == NULL) { res = &dummy; } len = string_size(buf); assert(len); StringInit(res, self->addr, self->size, self->len); while (true) { if (res->len < len) { StringInit(res, NULL, 0, 0); return false; } if (_StringStartsWith(res, buf)) { res->len = (uint32_t)len; res->size = len; return true; } res->size = res->len - 1; res->len = res->len - 1; ++res->addr; } }
static rc_t vds_print_diff( const char * buffer1, const char * buffer2, size_t len1, size_t len2 ) { rc_t rc; String S1, S2; StringInit( &S1, buffer1, len1, len1 ); StringInit( &S2, buffer2, len2, len2 ); rc = KOutMsg( "\n[A] %S\n", &S1 ); if ( rc == 0 ) rc = KOutMsg( "[B] %S\n", &S2 ); return rc; }
CMyString::CMyString(const char *psz) { //需先进行初始化 StringInit(); SetString(psz); }
static void StringTrim ( String *trim, const String *source ) { uint32_t str_len = source -> len; const char *start = source -> addr; const char *end = start + source -> size; while ( start < end ) { if ( ! isspace ( * start ) ) break; ++ start; -- str_len; } while ( end > start ) { if ( ! isspace ( end [ - 1 ] ) ) break; -- end; -- str_len; } StringInit ( trim, start, end - start, str_len ); }
/* Make * make a column ref from an SColumn* */ rc_t VColumnRefMake ( VColumnRef **rp, const VSchema *schema, const SColumn *scol ) { char text [ 256 ]; rc_t rc = VTypedeclToText ( & scol -> td, schema, text, sizeof text ); if ( rc == 0 ) { size_t tdsize = strlen ( text ); const String *name = & scol -> name -> name; VColumnRef *cref = malloc ( sizeof * cref + name -> size + tdsize ); if ( cref == NULL ) rc = RC ( rcVDB, rcTable, rcListing, rcMemory, rcExhausted ); else { strcpy ( cref -> typedecl, text ); string_copy ( & cref -> typedecl [ tdsize + 1 ], name -> size + 1, name -> addr, name -> size ); StringInit ( & cref -> name, & cref -> typedecl [ tdsize + 1 ], name -> size, name -> len ); cref -> td = scol -> td; cref -> cid = scol -> cid; cref -> dflt = scol -> dflt; * rp = cref; } } return rc; }
/* ---------------------------------------------------------------------- * KTocEntryNewSoft * * [RET] rc_t 0 for success; anything else for a failure * see itf/klib/rc.h for general details * [OUT] KTocEntry ** new_entry where to put a pointer to the new TOC Entry * [IN] const char * name name of the file (not path) (not assumed to be ASCIZ) * [IN] size_t name_size length of name * [IN] uint32_t access unix/posix style permission flags * [IN] const char * link character array (string) holding the name of the * links target (not assumed to be ASCIZ) * [IN] size_t link_size length of the target string * Link is run time resolved */ rc_t KTocEntryNewSoft ( KTocEntry ** new_entry, const char * name, size_t name_size, KTime_t mtime, uint32_t access, const char * link, size_t link_size ) { rc_t rc; char * linkp; rc = KTocEntryNew (new_entry, name, name_size, mtime, access, (sizeof(KTocEntry) - sizeof(union KTocEntryUnion)) + sizeof(struct KTocEntrySoftLink) + link_size + 1); if (rc != 0) { return rc; } (*new_entry)->type = ktocentrytype_softlink; linkp =(char*)(*new_entry) + sizeof(KTocEntry) - sizeof(union KTocEntryUnion) + sizeof(struct KTocEntrySoftLink); string_copy (linkp, link_size+1, link, link_size); StringInit ( &((*new_entry)->u.symbolic_link.link_path), linkp, link_size, (uint32_t)link_size ); return 0; }
/* ---------------------------------------------------------------------- * KTocEntryNew * * [RET] rc_t 0 for success; anything else for a failure * see itf/klib/rc.h for general details * [OUT] KTocEntry ** new_entry where to put a pointer to the new TOC Entry * [IN] const char * name name of the entry (file, link, directory...) * (not assumed to be ASCIZ) * [IN] size_t name_size length of name * [IN] uint32_t access unix/posix style permission flags * [IN] size_t entry_specific specific initialyers by entry type */ static rc_t KTocEntryNew (KTocEntry ** new_entry, const char * name, size_t name_size, KTime_t mtime, uint32_t access, size_t entry_specific) { KTocEntry * entry; size_t nsize; char * namep; nsize = entry_specific + name_size + 1; /* we want a NUL at end of name */ entry = malloc (nsize); if (entry == NULL) { LOGMSG (klogErr, "Failed to allocate for a TOC File entry"); return RC (rcFS, rcToc, rcAllocating, rcMemory, rcInsufficient); } /* entry->entry is fine left as undefined */ namep =(char*)entry + entry_specific; string_copy (namep, name_size+1, name, name_size); StringInit (&(entry->name), namep, name_size, (uint32_t)name_size); entry->mtime = mtime; entry->access = access; *new_entry = entry; return 0; }
static rc_t KNSProxiesAddHttpProxyPath ( KNSProxies * self, const char * proxy, size_t proxy_size, uint16_t proxy_port ) { const String * proxy_host = NULL; rc_t rc = 0; HttpProxy * new_proxy = NULL; BSTItem * node = NULL; HttpProxy add = { proxy_host, proxy_port, 0 }; assert ( self ); if ( proxy == NULL ) return 0; if ( rc == 0 ) { String tmp; StringInit ( & tmp, proxy, proxy_size, string_len ( proxy, proxy_size ) ); rc = StringCopy ( & proxy_host, & tmp ); if ( rc == 0 ) add . proxy_host = proxy_host; else return rc; } if ( BSTreeFind ( & self -> proxie_tree, & add, BSTItemCmp ) != NULL ) { DBGMSG ( DBG_KNS, DBG_FLAG ( DBG_KNS_PROXY ), ( "Ignored duplicate proxy '%S:%d'\n", proxy_host, proxy_port ) ); free ( ( void * ) proxy_host ); return 0; } new_proxy = calloc ( 1, sizeof * new_proxy ); if ( new_proxy == NULL ) return RC ( rcNS, rcMgr, rcAllocating, rcMemory, rcExhausted ); new_proxy -> proxy_host = proxy_host; new_proxy -> proxy_port = proxy_port; node = calloc ( 1, sizeof * node ); if ( node == NULL ) { free ( new_proxy ); return RC ( rcNS, rcMgr, rcAllocating, rcMemory, rcExhausted ); } node -> proxy = new_proxy; rc = BSTreeInsert ( & self -> proxie_tree, ( BSTNode * ) node, BSTreeSort ); DBGMSG ( DBG_KNS, DBG_FLAG ( DBG_KNS_PROXY ), ( "Added proxy '%S:%d'\n", proxy_host, proxy_port ) ); if ( ! self -> http_proxy_enabled ) self -> http_proxy_enabled = ( proxy_host != NULL ); return rc; }
LIB_EXPORT rc_t CC KNSManagerVSetHTTPProxyPath ( KNSManager * self, const char * fmt, va_list args ) { rc_t rc = 0; if ( self == NULL ) rc = RC ( rcNS, rcMgr, rcUpdating, rcSelf, rcNull ); else { uint16_t proxy_port = 0; const String * proxy = NULL; if ( fmt != NULL && fmt [ 0 ] != 0 ) { size_t psize; char path [ 4096 ]; rc = string_vprintf ( path, sizeof path, & psize, fmt, args ); if ( rc == 0 && psize != 0 ) { char * colon = string_rchr ( path, psize, ':' ); if ( colon != NULL ) { char * end; const char * port_spec = colon + 1; /* it is true that some day we might read symbolic port names... */ long port_num = strtol ( port_spec, & end, 10 ); if ( port_num <= 0 || port_num >= 0x10000 || end [ 0 ] != 0 ) rc = RC ( rcNS, rcMgr, rcUpdating, rcPath, rcInvalid ); else { proxy_port = ( uint64_t ) port_num; psize = colon - path; } } if ( rc == 0 ) { String tmp; StringInit ( & tmp, path, psize, string_len ( path, psize ) ); rc = StringCopy ( & proxy, & tmp ); } } } if ( rc == 0 ) { if ( self -> http_proxy != NULL ) { StringWhack ( self -> http_proxy ); self -> http_proxy_port = 0; } self -> http_proxy = proxy; self -> http_proxy_enabled = ( proxy != NULL ); self -> http_proxy_port = proxy_port; } } return rc; }
rc_t KeyRingGetProject(KKeyRing* self, const String* name, String* download_ticket, String* encryption_key) { rc_t rc = 0; const Project* p; assert(self && name && download_ticket && encryption_key); p = KeyRingDataGetProject(self->data, name); if (p != NULL) { StringInit(download_ticket, p->download_ticket->addr, p->download_ticket->len, p->download_ticket->size); StringInit(encryption_key, p->encryption_key->addr, p->encryption_key->len, p->encryption_key->size); } else rc = RC(rcApp, rcDatabase, rcSearching, rcName, rcNotFound); return rc; }
String* StringNew(guint length) { String* res; res = newvarobj(String, gchar, length); StringInit(res, length); return res; }
static rc_t FastqSequenceInit(FastqSequence* self) { self->sequence_vt.v1 = & FastqSequence_vt; KRefcountInit ( & self -> refcount, 1, "FastqSequence", "FastqSequenceInit", ""); StringInit(&self->spotname, 0, 0, 0); StringInit(&self->spotgroup, 0, 0, 0); self->readnumber = 0; StringInit(&self->read, 0, 0, 0); self->is_colorspace = false; StringInit(&self->quality, 0, 0, 0); self->qualityAsciiOffset = 0; self->lowQuality = false; return 0; }
CMyNumString::CMyNumString(const char *psz) { StringInit(); if (!CheckNum(psz)) { return; } StringCopy(psz); }
CMyNumString::CMyNumString(const CMyNumString &str) { StringInit(); if (!CheckNum(str.m_psz)) { return; } CMyString::CMyString(str); }
static rc_t aws_extract_key_value_pair ( const String *source, String *key, String *val ) { String k, v; const char *start = source -> addr; const char *end = start + source -> size; char *eql = string_chr ( start, source -> size, '=' ); if ( eql == NULL ) return RC ( rcKFG, rcChar, rcSearching, rcFormat, rcInvalid ); /* key */ StringInit ( &k, start, eql - start, string_len ( start, eql - start ) ); StringTrim ( key, &k ); start = eql + 1; /* value */ StringInit ( &v, start, end - start, string_len ( start, end - start ) ); StringTrim ( val, &v ); return 0; }
rc_t KeyRingGetKey(KKeyRing* self, const struct String* object_name, struct String* encryption_key) { rc_t rc = 0; const Object* obj; assert(self && object_name && encryption_key); obj = KeyRingDataGetObject(self->data, object_name); if (obj != NULL) StringInit(encryption_key, obj->encryption_key->addr, obj->encryption_key->len, obj->encryption_key->size); else rc = RC(rcApp, rcDatabase, rcSearching, rcName, rcNotFound); return rc; }
static spotgrp * make_spotgrp( const char *src, const size_t len ) { spotgrp * sg = calloc( 1, sizeof sg[ 0 ] ); if ( sg != NULL ) { String s; StringInit( &s, src, len, len ); if ( StringCopy ( &sg->name, &s ) != 0 ) { free( sg ); sg = NULL; } } return sg; }
/* Make */ static rc_t KDylibMake ( KDylib **libp, const String *path ) { KDylib *lib = malloc ( sizeof * lib + path -> size + 1 ); if ( lib == NULL ) return RC ( rcFS, rcDylib, rcConstructing, rcMemory, rcExhausted ); lib -> handle = NULL; string_copy ( ( char* ) ( lib + 1 ), path -> size + 1, path -> addr, path -> size ); StringInit ( & lib -> path, ( char* ) ( lib + 1 ), path -> size, path -> len ); KRefcountInit ( & lib -> refcount, 1, "KDylib", "make", lib -> path . addr ); * libp = lib; return 0; }
CMyString::~CMyString() { #ifdef REFCOUNT Release(); #else if (m_psz) { delete[] m_psz; } #endif StringInit(); }
CMyString::CMyString(const CMyString &str) { StringInit(); #ifdef REFCOUNT //进行浅拷贝 m_nlen = str.m_nlen; m_nspace = str.m_nspace; m_psz = str.m_psz; m_prefcount = str.m_prefcount; AddRef(); #else SetString(str); #endif }
static rc_t init_ictx( struct ictx * ictx, const dump_context * ctx, const Args * args ) { rc_t rc = KFileMakeStdIn ( &( ictx->std_in ) ); DISP_RC( rc, "KFileMakeStdIn() failed" ); if ( rc == 0 ) { ictx->ctx = ctx; ictx->args = args; VectorInit( &ictx->history, 0, 10 ); ictx->interactive = ( KFileType ( ictx->std_in ) == kfdCharDev ); ictx->done = false; CONST_STRING( &(ictx->PROMPT), "\nvdb $" ); StringInit( &(ictx->SInputLine), &( ictx->inputline[0] ), sizeof( ictx->inputline ), 0 ); rc = vdp_init_ctx( &ictx->vsctx, args ); } return rc; }
static rc_t cg_dump_row( cg_dump_opts * opts, cg_dump_ctx * cg_ctx, uint64_t row_id ) { uint32_t elem_bits, boff, sg_len; const char * sg; rc_t rc = VCursorCellDataDirect( cg_ctx->seq_cur, row_id, cg_ctx->seq_sg_idx, &elem_bits, (const void**)&sg, &boff, &sg_len ); if ( rc != 0 ) { (void)PLOGERR( klogErr, ( klogErr, rc, "cannot read spot-group in row #$(row_id)", "row_id=%lu", row_id ) ); } else { String spot_group; lane * sg_lane; StringInit( &spot_group, sg, sg_len, sg_len ); sg_lane = ( lane * )BSTreeFind ( &cg_ctx->lanes, &spot_group, String_lane_cmp ); if ( sg_lane == NULL ) { /* KOutMsg( "row %lu (%S) not found, create it\n", row_id, &spot_group ); */ rc = make_lane( opts, cg_ctx->lookup, cg_ctx->out_dir, &spot_group, &sg_lane ); if ( rc == 0 ) { rc = BSTreeInsert ( &cg_ctx->lanes, ( BSTNode * )sg_lane, lane_lane_cmp ); if ( rc != 0 ) { (void)LOGERR( klogErr, rc, "cannot insert new lane" ); whack_lane( sg_lane ); } } } else { /* KOutMsg( "row %lu (%S) found, use it\n", row_id, &spot_group ); */ } if ( rc == 0 ) { cg_dump_write_spot( opts, cg_ctx, row_id, sg_lane ); /* <================== */ } } return rc; }
/* Make */ static KThreadEvent * KThreadEventMake ( ctx_t ctx, uint32_t lineno, xc_sev_t severity, xc_org_t origin, xc_t xc, const char * msg, va_list args ) { KThreadEvent * evt; KTime_t ts = KTimeStamp (); char * c; size_t num_writ; char msg_buffer [ 4096 ]; rc_t rc = string_vprintf ( msg_buffer, sizeof msg_buffer, & num_writ, msg, args ); if ( rc != 0 || num_writ >= sizeof msg_buffer ) string_printf ( msg_buffer, sizeof msg_buffer, & num_writ, "** BAD MESSAGE STRING **" ); if ( num_writ > 0 && msg_buffer [ num_writ - 1 ] == '.' ) msg_buffer [ -- num_writ ] = 0; evt = malloc ( sizeof * evt + num_writ + 1 ); if ( evt == NULL ) { /* ATTEMPT TO DUMP TO LOG */ KThreadEventDump ( ctx, ts, ctx -> loc, lineno, severity, origin, xc, msg_buffer, NULL ); exit ( -1 ); } evt -> node = NULL; evt -> next = NULL; evt -> xc = ( const XCErr * ) xc; evt -> timestamp = ts; evt -> severity = severity; evt -> origin = origin; evt -> lineno = lineno; c = ( char* ) ( evt + 1 ); memmove ( c, msg_buffer, num_writ + 1 ); StringInit ( & evt -> message, c, num_writ, string_len ( c, num_writ ) ); return evt; }
void Init(char *langs, char *dialects, int anamorph) { Starting = 1; GenOnAssert = 1; LexEntryOff = 0; SaveTime = 1; /* SaveTime = 1: no spell correction hashing or phrase derivation, * saves memory. * SaveTime = 0: uses more time and memory. */ qallocInit(); DbgInit(); DbgSet(DBGALL, DBGBAD); DbgSetStdoutLevel(DBGOK); NoticePrint(stderr); NoticePrint(Log); EnvInit(); StringInit(); RandomInit(); GridInit(); ObjInit(); ObjListInit(); DbInit(); ContextInit(); TsInit(); TsRangeInit(); LexEntryInit(); Lex_WordForm2Init(); MorphInit(anamorph); WordFormInit(); InferenceInit(); ReportInit(); CommentaryInit(); TranslateInit(); LearnInit(); StopAtInit(); TT_HTML_Init(); StdDiscourse = DiscourseCreate(langs, dialects); DiscourseSetLang(StdDiscourse, F_ENGLISH); Starting = 0; }
static spotgrp * make_spotgrp( const char *src, const size_t len ) { spotgrp * sg = calloc( 1, sizeof sg[ 0 ] ); if ( sg != NULL ) { String s; StringInit( &s, src, len, len ); if ( StringCopy ( &sg->name, &s ) != 0 ) { free( sg ); sg = NULL; } #ifdef USE_JUDY else { KVectorMake ( &sg->v ); } #endif } return sg; }
static spotgrp * find_spotgroup( statistic *self, const char *src, const size_t len ) { String s; BSTNode *node; StringInit( &s, src, len, len ); if ( self->last_used_spotgroup != NULL ) { spotgrp * sg = ( spotgrp* )self->last_used_spotgroup; if ( StringCompare ( &s, sg->name ) == 0 ) return sg; } node = BSTreeFind ( &self->spotgroups, &s, spotgroup_find ); if ( node == NULL ) return NULL; else { self->last_used_spotgroup = node; return ( spotgrp *) node; } }
static bool VTableNameAvail ( const KSymTable *tbl, const char *name ) { String str; /* build a physical name from simple name */ char pname [ 256 ]; int len = snprintf ( pname, sizeof pname, ".%s", name ); if ( len < 0 || len >= sizeof pname ) return false; /* test for defined physical name */ StringInit ( & str, pname, len, len ); if ( KSymTableFind ( tbl, & str ) != NULL ) return false; /* test for defined simple name */ StringSubstr ( & str, & str, 1, 0 ); if ( KSymTableFind ( tbl, & str ) != NULL ) return false; /* name is available */ return true; }
int main(void) { MainInit(); I2C1init(); RtcInit(); LcdInit(); DataLogInit(); StringInit(); Mct485Init(); FieldInit(); Ads1115Init(); Ads1244Init(); USBInit(); RtuInit(); AdcInit(); TC74Init(); // enable multi-vector interrupts INTEnableSystemMultiVectoredInt(); MainDelay(50); DataLogDateTime(DLOG_SFC_POWERUP); // init param after interrupts are enabled ParamInit(); // wait to init desiccant until after ParamInit DesiccantInit(); string[0].mct[0].chan[4] = 0x7FFF; // // Begin Main Loop // for (;;) { if (test == 1) { test = 0; FieldNewState((FIELD_STATE_m)t1); } USBUpdate(); // called as often as possible //sysTickEvent every ms if (sysTickEvent) { sysTickEvent = 0; sysTicks++; UsbTimeoutUpdate(); LcdUpdate(); // fill time before dropping LCD_E if (sysTicks >= 1000) { sysSec++; sysTicks = 0; mPORTDToggleBits(PD_LED_HEARTBEAT); // These Updates are // called once a second //TODO if any of these are long, we could split them on separate milliseconds. DesiccantUpdate(); AdcUpdate(); TC74Update(); }// end 1 Hz else if (sysTicks == 250) { mPORTDToggleBits(PD_LED_HEARTBEAT); } else if (sysTicks == 500) { mPORTDToggleBits(PD_LED_HEARTBEAT); } else if (sysTicks == 750) { mPORTDToggleBits(PD_LED_HEARTBEAT); } // Complete LcdUpdate() by dropping LCD_E) PORTClearBits(IOPORT_G, PG_LCD_E); // These Updates called once each millisecond RtcUpdate(); I2C1update(); StringUpdate(); Mct485Update(); FieldUpdate(); RtuUpdate(); DessicantFanPWMupdate(); } // if (sysTickEvent) } // for (;;) } // main()
static void aws_parse_file ( const KFile *self, KConfigNode *aws_node, char *buffer, size_t buf_size, bool isCredentialsFile ) { char *sep; const char *start = buffer; const char *end = start + buf_size; for ( ; start < end; start = sep + 1 ) { rc_t rc; String string, trim; String key, value; sep = string_chr ( start, end - start, '\n' ); if ( sep == NULL ) sep = ( char * ) end; StringInit ( &string, start, sep - start, string_len ( start, sep - start ) ); StringTrim ( &trim, &string ); /* check for comment line and skip */ if ( StringLength ( & trim ) != 0 && trim . addr [ 0 ] == '#' ) continue; /* check for key/value pairs and skip if none found */ rc = aws_extract_key_value_pair ( &trim, &key, &value ); if ( rc != 0 ) continue; /* now check keys we are looking for and populate the node*/ if ( isCredentialsFile ) { String access_key_id, secret_access_key; CONST_STRING ( &access_key_id, "aws_access_key_id" ); CONST_STRING ( &secret_access_key, "aws_secret_access_key" ); if ( StringCaseEqual ( &key, &access_key_id ) ) { rc = aws_KConfigNodeUpdateChild ( aws_node, &key, &value ); if ( rc != 0 ) return; } if ( StringCaseEqual ( &key, &secret_access_key ) ) { rc = aws_KConfigNodeUpdateChild ( aws_node, &key, &value ); if ( rc != 0 ) return; } } else { String region, output; CONST_STRING ( ®ion, "region" ); CONST_STRING ( &output, "output" ); if ( StringCaseEqual ( &key, ®ion ) ) { rc = aws_KConfigNodeUpdateChild ( aws_node, &key, &value ); if ( rc != 0 ) return; } if ( StringCaseEqual ( &key, &output ) ) { rc = aws_KConfigNodeUpdateChild ( aws_node, &key, &value ); if ( rc != 0 ) return; } } } }
rc_t ascpParse(const char *buf, size_t len, const char *filename, EAscpState *state, String *line) { bool failure = false; const char *p = buf; int64_t l = len; assert(buf && len && filename && state && line); StringInit(line, NULL, 0, 0); while (true) { const char *n = string_chr(p, l, '\n'); const char *r = string_chr(p, l, '\r'); if (n == NULL) { if (r != NULL) { n = r; } } else { if (r != NULL) { if (r < n) { n = r; } } } if (n != NULL) { StringInit(line, p, n - p, (uint32_t)(n - p)); l -= n - p + 1; } else { StringInit(line, p, l, (uint32_t)l); } if (line->addr && line->len && line->addr[line->len - 1] == '\r') { line->size = line->len - 1; line->len = line->len - 1; } if (line->addr && line->len && line->addr[0] == '\r') { ++line->addr; line->size = line->len - 1; line->len = line->len - 1; } if (line->len != 0) { SAscpState full; rc_t rc = parseAscpLine(line, &full, filename); if (rc != 0) { return rc; } switch (full.s) { case eChild: break; case eUnknown: switch (*state) { case eKeyStart: case eKeyMayBeIn: case eKeyIn: *state = eKeyMayBeIn; break; case eCompleted: case eFailed: case eWriteFailed: *state = eEnd; /* report to user */ break; case eProgress: if (sStatus) { OUTMSG(("\n")); } /* no break; */ default: *state = eUnknown; /* report to user */ break; } break; case eFailed: if (*state == eProgress) { if (sStatus) { OUTMSG(("\n")); } } failure = true; *state = full.s; if (sStatus) { OUTMSG(("%s\n", full.msg)); } /* no break; */ break; case eWriteFailed: if (*state == eProgress) { if (sStatus) { OUTMSG(("\n")); } } failure = true; *state = full.s; if (sStatus) { OUTMSG(("%s\n", full.msg)); } /* no break; */ break; case eCompleted: if (*state == eProgress) { if (sStatus) { OUTMSG(("\n")); } } failure = false; *state = full.s; if (sStatus) { OUTMSG(("%s\n", full.msg)); } /* no break; */ break; case eProgress: if (*state == eProgress) { if (sStatus) { OUTMSG(("\r")); } } *state = full.s; if (sStatus) { OUTMSG(("%s", full.msg)); } break; case eEnd: if (*state == eProgress) { if (sStatus) { OUTMSG(("\n")); } } *state = full.s; if (sStatus) { OUTMSG(("%s\n", full.msg)); } /* report to user */ break; default: *state = full.s; break; } SAscpStateFini(&full); } if (n == NULL || l <= 0) { break; } if (*state == eKeyEnd) { String end; if (_StringHas(line, "Store key in cache? (y/n) ", &end)) { if (n > end.addr + end.len) { l += n - end.addr + end.len; n = end.addr + end.len - 1; } } } p = n + 1; if (p >= buf + len) { break; } } if (sStatus) { STSMSG(STS_FIN, ("%.*s", len, buf)); } if (failure) { /* ignore it */ } return 0; }