自学教程：C++ uL函数代码示例

/* * `nread` (siz_w) is > 0 if there is data available, 0 if libuv is done reading for * now, or < 0 on error. * * The callee is responsible for closing the stream when an error happens * by calling uv_close(). Trying to read from the stream again is undefined. * * The callee is responsible for freeing the buffer, libuv does not reuse it. * The buffer may be a null buffer (where buf->base=NULL and buf->len=0) on * error. */static void_http_conn_read_cb(uv_stream_t* tcp_u,                   ssize_t      siz_w,                   const uv_buf_t *     buf_u){  u3_hcon* hon_u = (u3_hcon*)(void*) tcp_u;  u3_lo_open();  {    if ( siz_w == UV_EOF ) {      _http_conn_dead(hon_u);          } else if ( siz_w < 0 ) {      uL(fprintf(uH, "http: read: %s/n", uv_strerror(siz_w)));      _http_conn_dead(hon_u);    }    else {      if ( !hon_u->ruc_u ) {        hon_u->ruc_u = _http_req_new(hon_u);      }      if ( siz_w != http_parser_execute(hon_u->ruc_u->par_u,                                        &_http_settings,                                        (c3_c*)buf_u->base,                                        siz_w) )      {        uL(fprintf(uH, "http: parse error/n"));        _http_conn_dead(hon_u);      }    }    if ( buf_u->base ) {      free(buf_u->base);    }  }  u3_lo_shut(c3y);}

/* _unix_watch_dir(): initialize directory*/static void_unix_watch_dir(u3_udir* dir_u, u3_udir* par_u, c3_c* pax_c){    // initialize dir_u    dir_u->dir = c3y;    dir_u->dry = c3n;    dir_u->pax_c = pax_c;    dir_u->par_u = par_u;    dir_u->nex_u = NULL;    dir_u->kid_u = NULL;    if ( par_u ) {        dir_u->nex_u = par_u->kid_u;        par_u->kid_u = (u3_unod*) dir_u;    }    // stuff dir_u into libuv    // note that we're doing something tricky here    // see comment in _unix_fs_event_cb    c3_w ret_w = uv_fs_event_init(u3L, &dir_u->was_u);    if (0 != ret_w) {        uL(fprintf(uH, "directory event init: %s/n", uv_strerror(ret_w)));        c3_assert(0);    }    ret_w = uv_fs_event_start(&dir_u->was_u, _unix_fs_event_cb, pax_c, 0);    if (0 != ret_w) {        uL(fprintf(uH, "directory event start: %s/n", uv_strerror(ret_w)));        c3_assert(0);    }}

/* unix_save(): save a file.*/static void_unix_save(c3_c* pax_c, u2_atom oat){  c3_i  fid_i = open(pax_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);  c3_w  fln_w, rit_w;  c3_y* oat_y;  if ( fid_i < 0 ) {    uL(fprintf(uH, "%s: %s/n", pax_c, strerror(errno)));    u2_cm_bail(c3__fail);  }  fln_w = u2_met(3, oat);  oat_y = malloc(fln_w);  u2_cr_bytes(0, fln_w, oat_y, oat);  u2z(oat);  rit_w = write(fid_i, oat_y, fln_w);  close(fid_i);  free(oat_y);  if ( rit_w != fln_w ) {    uL(fprintf(uH, "%s: %s/n", pax_c, strerror(errno)));    c3_assert(0);  }}

/* u3_sist_put(): moronic key-value store put.*/voidu3_sist_put(const c3_c* key_c, const c3_y* val_y, size_t siz_i){  c3_c ful_c[2048];  c3_i ret_i;  c3_i fid_i;  ret_i = snprintf(ful_c, 2048, "%s/.urb/sis/_%s", u3_Host.dir_c, key_c);  c3_assert(ret_i < 2048);  if ( (fid_i = open(ful_c, O_CREAT | O_TRUNC | O_WRONLY, 0600)) < 0 ) {    uL(fprintf(uH, "sist: could not put %s/n", key_c));    perror("open");    u3_lo_bail();  }  if ( (ret_i = write(fid_i, val_y, siz_i)) != siz_i ) {    uL(fprintf(uH, "sist: could not write %s/n", key_c));    if ( ret_i < 0 ) {      perror("write");    }    u3_lo_bail();  }  ret_i = c3_sync(fid_i);  if ( ret_i < 0 ) {    perror("sync");  }  ret_i = close(fid_i);  c3_assert(0 == ret_i);}

/* _http_respond(): attach http response.*/static void_http_respond(u3_hrep* rep_u){  u3_http* htp_u;  u3_hcon* hon_u;  u3_hreq* req_u;  if ( !(htp_u = _http_serv_find(rep_u->sev_l)) ) {    uL(fprintf(uH, "http: server not found: %x/r/n", rep_u->sev_l));    return;  }  if ( !(hon_u = _http_conn_find(htp_u, rep_u->coq_l)) ) {    uL(fprintf(uH, "http: connection not found: %x/%d/r/n",                   rep_u->sev_l,                   rep_u->coq_l));    return;  }  if ( !(req_u = _http_req_find(hon_u, rep_u->seq_l)) ) {    uL(fprintf(uH, "http: request not found: %x/%d/%d/r/n",                    rep_u->sev_l,                    rep_u->coq_l,                    rep_u->seq_l));    return;  }#if 0  uL(fprintf(uH, "http: responding: %x/%d/%d/r/n",                  rep_u->sev_l,                  rep_u->coq_l,                  rep_u->seq_l));#endif  _http_respond_request(req_u, rep_u);  _http_flush(hon_u);}

/* u3_sist_get(): moronic key-value store get.*/voidu3_sist_get(const c3_c* key_c, c3_y* val_y){  c3_c        ful_c[2048];  c3_i        ret_i;  c3_i        fid_i;  struct stat sat_u;  ret_i = snprintf(ful_c, 2048, "%s/.urb/sis/_%s", u3_Host.dir_c, key_c);  c3_assert(ret_i < 2048);  if ( (fid_i = open(ful_c, O_RDONLY)) < 0 ) {    uL(fprintf(uH, "sist: could not get %s/n", key_c));    perror("open");    u3_lo_bail();  }  if ( (ret_i = fstat(fid_i, &sat_u)) < 0 ) {    uL(fprintf(uH, "sist: could not stat %s/n", key_c));    perror("fstat");    u3_lo_bail();  }  if ( (ret_i = read(fid_i, val_y, sat_u.st_size)) != sat_u.st_size ) {    uL(fprintf(uH, "sist: could not read %s/n", key_c));    if ( ret_i < 0 ) {      perror("read");    }    u3_lo_bail();  }  ret_i = close(fid_i);  c3_assert(0 == ret_i);}

//--------------------// egzh minifile work queue test////--------------------static void _test_egz_queue(){  void _enqueue(c3_d new_d,  c3_y msgtype_y);  c3_t _dequeue(c3_d * ret_d,  c3_y * msgtype_y);  // this inits mutex...and also starts consolidator thread (which we do NOT want)  // what's our solution to test just consolidator?  ignore for now.  u2_egz_init();  _enqueue(10, 0);  _enqueue(20, 0);  _enqueue(30, 0);  c3_t ret;  c3_d number;  c3_y msgtype_y;  ret = _dequeue(&number, & msgtype_y);  if (! (ret == c3_true && number == 10)){ uL(fprintf(uH, "FAIL - egz_queue 1/n")); exit(-1);}  ret = _dequeue(&number, & msgtype_y);  if (! (ret == c3_true && number == 20)){ uL(fprintf(uH, "FAIL - egz_queue 2/n")); exit(-1);}  ret = _dequeue(&number, & msgtype_y);  if (! (ret == c3_true && number == 30)){ uL(fprintf(uH, "FAIL - egz_queue 3/n")); exit(-1);}  // expect failure here  ret = _dequeue(&number, & msgtype_y);  if (! (ret == c3_false)){ uL(fprintf(uH, "FAIL - egz_queue 4/n")); exit(-1);}  uL(fprintf(uH, "PASS - egz_queue/n"));}

/* _unix_dir_watch(): instantiate directory tracker.*/static void_unix_dir_watch(u2_udir* dir_u, u2_udir* par_u, c3_c* pax_c){  // (1) build data structure  //  dir_u->yes = u2_yes;  dir_u->dry = u2_no;  dir_u->pax_c = pax_c;  dir_u->par_u = par_u;  dir_u->dis_u = 0;  dir_u->fil_u = 0;  dir_u->nex_u = 0;  // (2) stuff data structure into libuv  //  c3_w ret_w = uv_fs_event_init(u2L, &dir_u->was_u );  if (0 != ret_w){    uL(fprintf(uH, "event init: %s/n", uv_strerror(ret_w)));    c3_assert(0);  }  // note that we're doing something tricky here; see comment in _unix_fs_event_cb  //  ret_w = uv_fs_event_start(&dir_u->was_u,                           _unix_fs_event_cb,                           pax_c,                           0);  if (0 != ret_w){    uL(fprintf(uH, "event start: %s/n", uv_strerror(ret_w)));    c3_assert(0);  }}

/* u2_walk_save(): save file or bail.*/voidu2_walk_save(c3_c* pas_c, u2_noun tim, u2_atom pad){  c3_i  fid_i = open(pas_c, O_WRONLY | O_CREAT | O_TRUNC, 0666);  c3_w  fln_w, rit_w;  c3_y* pad_y;  if ( fid_i < 0 ) {    uL(fprintf(uH, "%s: %s/n", pas_c, strerror(errno)));    u2_cm_bail(c3__fail);  }  fln_w = u2_met(3, pad);  pad_y = malloc(fln_w);  u2_cr_bytes(0, fln_w, pad_y, pad);  u2z(pad);  rit_w = write(fid_i, pad_y, fln_w);  close(fid_i);  free(pad_y);  if ( rit_w != fln_w ) {    uL(fprintf(uH, "%s: %s/n", pas_c, strerror(errno)));    u2_cm_bail(c3__fail);  }  if ( 0 != tim ) {    struct timeval tim_tv[2];    u2_time_out_tv(&tim_tv[0], u2k(tim));    u2_time_out_tv(&tim_tv[1], tim);     utimes(pas_c, tim_tv);  }}

/* _unix_watch_file(): initialize file*/static void_unix_watch_file(u3_ufil* fil_u, u3_udir* par_u, c3_c* pax_c){    // initialize fil_u    fil_u->dir = c3n;    fil_u->dry = c3n;    fil_u->pax_c = pax_c;    fil_u->par_u = par_u;    fil_u->nex_u = NULL;    fil_u->mug_w = 0;    fil_u->gum_w = 0;    if ( par_u ) {        fil_u->nex_u = par_u->kid_u;        par_u->kid_u = (u3_unod*) fil_u;    }    // stuff fil_u into libuv    // note that we're doing something tricky here    // see comment in _unix_fs_event_cb    c3_w ret_w = uv_fs_event_init(u3L, &fil_u->was_u);    if (0 != ret_w) {        uL(fprintf(uH, "file event init: %s/n", uv_strerror(ret_w)));        c3_assert(0);    }    ret_w = uv_fs_event_start(&fil_u->was_u, _unix_fs_event_cb, pax_c, 0);    if ( 0 != ret_w ) {        uL(fprintf(uH, "file event start %s: %s/n", fil_u->pax_c, uv_strerror(ret_w)));        c3_assert(0);    }}

BYTE palette_load_from_file(const uTCHAR *file) {	FILE *fp;	memset((BYTE *) palette_base_file, 0x00, 64 * 3);	if ((fp = ufopen(file, uL("rb"))) == NULL) {		ufprintf(stderr, uL("ERROR: open file " uPERCENTs "/n"), file);		return (EXIT_ERROR);	}	fseek(fp, 0, SEEK_END);	if (ftell(fp) < (64 * 3)) {		ufprintf(stderr, uL("ERROR: read file " uPERCENTs "/n"), file);		fclose(fp);		return (EXIT_ERROR);	}	rewind(fp);	if (!(fread((BYTE *) palette_base_file, 64 * 3, 1, fp))) {		;	}	fclose(fp);	return (EXIT_OK);}

/* _unix_write_file_soft(): write to a file, not overwriting if it's changed*/static void_unix_write_file_soft(u3_ufil* fil_u, u3_noun mim){    struct stat buf_u;    c3_i  fid_i = open(fil_u->pax_c, O_RDONLY, 0644);    c3_ws len_ws, red_ws;    c3_w  old_w;    c3_y* old_y;    if ( fid_i < 0 || fstat(fid_i, &buf_u) < 0 ) {        if ( ENOENT == errno ) {            goto _unix_write_file_soft_go;        }        else {            uL(fprintf(uH, "error opening file (soft) %s: %s/r/n",                       fil_u->pax_c, strerror(errno)));            u3z(mim);            return;        }    }    len_ws = buf_u.st_size;    old_y = c3_malloc(len_ws);    red_ws = read(fid_i, old_y, len_ws);    if ( close(fid_i) < 0 ) {        uL(fprintf(uH, "error closing file (soft) %s: %s/r/n",                   fil_u->pax_c, strerror(errno)));    }    if ( len_ws != red_ws ) {        if ( red_ws < 0 ) {            uL(fprintf(uH, "error reading file (soft) %s: %s/r/n",                       fil_u->pax_c, strerror(errno)));        }        else {            uL(fprintf(uH, "wrong # of bytes read in file %s: %d %d/r/n",                       fil_u->pax_c, len_ws, red_ws));        }        free(old_y);        u3z(mim);        return;    }    old_w = u3r_mug_bytes(old_y, len_ws);    if ( old_w != fil_u->gum_w ) {        fil_u->gum_w = u3r_mug(u3t(u3t(mim))); // XXX this might fail with        free(old_y);                           //     trailing zeros        u3z(mim);        return;    }    free(old_y);_unix_write_file_soft_go:    fil_u->gum_w = _unix_write_file_hard(fil_u->pax_c, mim);}

/* u2_unix_acquire(): acquire a lockfile, killing anything that holds it.*/voidu2_unix_acquire(c3_c* pax_c){  c3_c* paf_c = _unix_down(pax_c, ".vere.lock");  c3_w pid_w;  FILE* loq_u;  if ( NULL != (loq_u = fopen(paf_c, "r")) ) {    if ( 1 != fscanf(loq_u, "%u", &pid_w) ) {      uL(fprintf(uH, "lockfile %s is corrupt!/n", paf_c));      kill(getpid(), SIGTERM);      sleep(1); c3_assert(0);    }    else {      c3_w i_w;      if ( -1 != kill(pid_w, SIGTERM) ) {        uL(fprintf(uH, "unix: stopping process %d, live in %s.../n",                         pid_w, pax_c));        for ( i_w = 0; i_w < 16; i_w++ ) {          sleep(1);          if ( -1 == kill(pid_w, SIGTERM) ) {            break;          }        }        if ( 16 == i_w ) {          for ( i_w = 0; i_w < 16; i_w++ ) {            if ( -1 == kill(pid_w, SIGKILL) ) {              break;            }            sleep(1);          }        }        if ( 16 == i_w ) {          uL(fprintf(uH, "process %d seems unkillable!/n", pid_w));          c3_assert(0);        }      }      uL(fprintf(uH, "unix: stopped old process %u/n", pid_w));    }    fclose(loq_u);    unlink(paf_c);  }  loq_u = fopen(paf_c, "w");  fprintf(loq_u, "%u/n", getpid());  {    c3_i fid_i = fileno(loq_u);#if defined(U2_OS_linux)    fdatasync(fid_i);#else    fcntl(fid_i, F_FULLFSYNC); #endif  }  fclose(loq_u);}

/* _unix_sync_change(): sync single change to unix*/static void_unix_sync_change(u3_udir* dir_u, u3_noun pax, u3_noun mim){    c3_assert( c3y == dir_u->dir );    if ( c3n == u3du(pax) ) {        if ( u3_nul == pax ) {            uL(fprintf(uH,"can't sync out file as top-level, strange/r/n"));        }        else {            uL(fprintf(uH,"sync out: bad path/r/n"));        }        u3z(pax);        u3z(mim);        return;    }    else if ( c3n == u3du(u3t(pax)) ) {        uL(fprintf(uH,"can't sync out file as top-level, strangely/r/n"));        u3z(pax);        u3z(mim);    }    else {        u3_noun i_pax = u3h(pax);        u3_noun t_pax = u3t(pax);        u3_noun it_pax = u3h(t_pax);        u3_noun tt_pax = u3t(t_pax);        if ( u3_nul == tt_pax ) {            _unix_sync_file(dir_u, u3k(i_pax), u3k(it_pax), mim);        }        else {            c3_c* nam_c = u3r_string(i_pax);            c3_w pax_w = strlen(dir_u->pax_c);            u3_unod* nod_u;            for ( nod_u = dir_u->kid_u;                    ( nod_u &&                      ( c3n == nod_u->dir ||                        0 != strcmp(nod_u->pax_c + pax_w + 1, nam_c) ) );                    nod_u = nod_u->nex_u )            { }            if ( !nod_u ) {                nod_u = c3_malloc(sizeof(u3_udir));                _unix_create_dir((u3_udir*) nod_u, dir_u, u3k(i_pax));            }            if ( c3n == nod_u->dir ) {                uL(fprintf(uH,                           "weird, we got a file when we weren't expecting to/r/n"));                c3_assert(0);            }            _unix_sync_change((u3_udir*) nod_u, u3k(t_pax), mim);        }    }    u3z(pax);}

/* u3_sist_boot(): restore or create.*/voidu3_sist_boot(void){  // uL(fprintf(uH, "sist: booting/n"));  if ( c3y == u3_Host.ops_u.nuu ) {    u3_noun pig = u3_none;    if ( 0 == u3_Host.ops_u.imp_c ) {      c3_c get_c[2049];      snprintf(get_c, 2048, "%s/.urb/get", u3_Host.dir_c);      if ( 0 == access(get_c, 0) ) {          uL(fprintf(uH, "pier: already built/n"));          u3_lo_bail();      }      u3_noun ten = _sist_zen();      uL(fprintf(uH, "generating 2048-bit RSA pair.../n"));      pig = u3nq(c3__make, u3_nul, 11, u3nc(ten, u3_Host.ops_u.fak));    }    else {      u3_noun imp = u3i_string(u3_Host.ops_u.imp_c);      u3_noun whu = u3dc("slaw", 'p', u3k(imp));      if ( (u3_nul == whu) ) {        fprintf(stderr, "czar: incorrect format/r/n");        u3_lo_bail();      }      else {        u3_noun gen = u3_nul;        u3_noun gun = u3_nul;        if (c3n == u3_Host.ops_u.fak) {          gen = _sist_text("generator");          gun = u3dc("slaw", c3__uw, gen);          if ( u3_nul == gun ) {            fprintf(stderr, "czar: incorrect format/r/n");            u3_lo_bail();          }        }        else {          gun = u3nc(u3_nul, u3_nul);        }        pig = u3nq(c3__sith,                   u3k(u3t(whu)),                   u3k(u3t(gun)),                   u3_Host.ops_u.fak);        u3z(whu); u3z(gun);      }      u3z(imp);    }    _sist_make(pig);  }  else {    _sist_rest();  }}

/* _unix_initial_update_dir(): read directory, but don't watch*/static u3_noun_unix_initial_update_dir(c3_c* pax_c){    u3_noun can = u3_nul;    DIR* rid_u = opendir(pax_c);    if ( !rid_u ) {        uL(fprintf(uH, "error opening initial directory: %s: %s/r/n",                   pax_c, strerror(errno)));        return u3_nul;    }    while ( 1 ) {        struct dirent  ent_u;        struct dirent* out_u;        c3_w err_w;        if ( 0 != (err_w = readdir_r(rid_u, &ent_u, &out_u)) ) {            uL(fprintf(uH, "error loading initial directory %s: %s/r/n",                       pax_c, strerror(errno)));            c3_assert(0);        }        else if ( !out_u ) {            break;        }        else if ( '.' == out_u->d_name[0] ) {            continue;        }        else {            c3_c* pox_c = _unix_down(pax_c, out_u->d_name);            struct stat buf_u;            if ( 0 != stat(pox_c, &buf_u) ) {                uL(fprintf(uH, "initial can't stat %s: %s/r/n",                           pox_c, strerror(errno)));                free(pox_c);                continue;            }            else {                if ( S_ISDIR(buf_u.st_mode) ) {                    can = u3kb_weld(_unix_initial_update_dir(pox_c), can);                }                else {                    can = u3kb_weld(_unix_initial_update_file(pox_c), can);                }                free(pox_c);            }        }    }    if ( closedir(rid_u) < 0 ) {        uL(fprintf(uH, "error closing initial directory %s: %s/r/n",                   pax_c, strerror(errno)));    }    return can;}

/* _http_write_cb(): general write callback.*/static void_http_write_cb(uv_write_t* wri_u, c3_i sas_i){  _u3_write_t* ruq_u = (void *)wri_u;  if ( (u3C.wag_w & u3o_verbose) && 0 != sas_i && UV__EPIPE != sas_i ) {    uL(fprintf(uH, "http: write: ERROR %d/n", sas_i));    uL(fprintf(uH, "  (%s)/n", uv_strerror(sas_i)));  }  free(ruq_u->buf_y);  free(ruq_u);}

/* _http_write_cb(): general write callback.*/static void_http_write_cb(uv_write_t* wri_u, c3_i sas_i){  _u3_write_t* ruq_u = (void *)wri_u;  if ( 0 != sas_i ) {    uL(fprintf(uH, "http: write: ERROR %d/n", sas_i));    uL(fprintf(uH, "  (%s)/n", uv_strerror(sas_i)));  }  free(ruq_u->buf_y);  free(ruq_u);}

/* _unix_initial_update_file(): read file, but don't watch*/static u3_noun_unix_initial_update_file(c3_c* pax_c){    struct stat buf_u;    c3_i  fid_i = open(pax_c, O_RDONLY, 0644);    c3_ws len_ws, red_ws;    c3_y* dat_y;    if ( fid_i < 0 || fstat(fid_i, &buf_u) < 0 ) {        if ( ENOENT == errno ) {            return u3_nul;        }        else {            uL(fprintf(uH, "error opening initial file %s: %s/r/n",                       pax_c, strerror(errno)));            return u3_nul;        }    }    len_ws = buf_u.st_size;    dat_y = c3_malloc(len_ws);    red_ws = read(fid_i, dat_y, len_ws);    if ( close(fid_i) < 0 ) {        uL(fprintf(uH, "error closing initial file %s: %s/r/n",                   pax_c, strerror(errno)));    }    if ( len_ws != red_ws ) {        if ( red_ws < 0 ) {            uL(fprintf(uH, "error reading initial file %s: %s/r/n",                       pax_c, strerror(errno)));        }        else {            uL(fprintf(uH, "wrong # of bytes read in initial file %s: %d %d/r/n",                       pax_c, len_ws, red_ws));        }        free(dat_y);        return u3_nul;    }    else {        u3_noun pax = _unix_string_to_path_helper(pax_c + strlen(U3_LIB) + 6); /* XX VERY BAD */        u3_noun mim = u3nt(c3__text, u3i_string("plain"), u3_nul);        u3_noun dat = u3nt(mim, len_ws, u3i_bytes(len_ws, dat_y));        free(dat_y);        return u3nc(u3nt(pax, u3_nul, dat), u3_nul);    }}

void palette_save_on_file(const uTCHAR *file) {	FILE *fp;	if ((fp = ufopen(file, uL("wb"))) == NULL) {		ufprintf(stderr, uL("ERROR: Impossible save palette file " uPERCENTs "/n"), file);		return;	}	if (!(fwrite((BYTE *) palette_RGB, 64 * 3, 1, fp))) {		;	}	fclose(fp);}

void js_init(void) {	BYTE i;	for (i = PORT1; i < PORT_MAX; i++) {		memset(&js[i], 0x00, sizeof(_js));		if (port[i].joy_id == name_to_jsn(uL("NULL"))) {			continue;		}		usnprintf(js[i].dev, usizeof(js[i].dev), uL("" JS_DEV_PATH "%d"), port[i].joy_id);		js[i].input_decode_event = input_decode_event[i];		js_open(&js[i]);	}}

/* _unix_file_watch(): create file tracker (from filesystem)*/static void_unix_file_watch(u2_ufil* fil_u,                 u2_udir* dir_u,                 c3_c*    pax_c,                 mpz_t    mod_mp){  // (1) build data structure  //  fil_u->non = u2_no;  fil_u->dry = u2_no;  fil_u->pax_c = pax_c;  {    c3_c* dot_c = strrchr(pax_c, '.');    c3_c* fas_c = strrchr(pax_c, '/');    fil_u->dot_c = dot_c ? (fas_c ? ((dot_c > fas_c) ? dot_c : 0)                            : dot_c)      : 0;  }  fil_u->par_u = dir_u;  mpz_init_set(fil_u->mod_mp, mod_mp);  fil_u->nex_u = 0;  c3_assert(!fil_u->dot_c || (fil_u->dot_c > fil_u->pax_c));  // (2) stuff data structure into libuv  //  c3_w ret_w = uv_fs_event_init(u2L,          // loop                                &fil_u->was_u // uv_fs_event_t                                 );  if (0 != ret_w){    uL(fprintf(uH, "event init: %s/n", strerror(ret_w)));    c3_assert(0);  }  // note that we're doing something tricky here; see comment in _unix_fs_event_cb  //  ret_w = uv_fs_event_start(&fil_u->was_u,     // uv_fs_event_t                            _unix_fs_event_cb, // callback                            pax_c,             // dir as strings                            0);                // flags  if (0 != ret_w){    uL(fprintf(uH, "event start: %s/n", strerror(ret_w)));    c3_assert(0);  }}

/* _sist_bask(): ask a yes or no question.*/static u3_noun_sist_bask(c3_c* pop_c, u3_noun may){  u3_noun yam;  uH;  while ( 1 ) {    c3_c ans_c[3];    printf("%s [y/n]? ", pop_c);    ans_c[0] = 0;    c3_fpurge(stdin);    fgets(ans_c, 2, stdin);    if ( (ans_c[0] != 'y') && (ans_c[0] != 'n') ) {      continue;    } else {      yam = (ans_c[0] != 'n') ? c3y : c3n;      break;    }  }  uL(0);  return yam;}

/* unix_load(): load a file.*/static u2_noun_unix_load(c3_c* pax_c){  struct stat buf_u;  c3_i        fid_i = open(pax_c, O_RDONLY, 0644);  c3_w        fln_w, red_w;  c3_y*       pad_y;  if ( (fid_i < 0) || (fstat(fid_i, &buf_u) < 0) ) {    //  ignore if the file disappeared between getting the sync event and now    if ( ENOENT != errno ) {      uL(fprintf(uH, "%s: %s/n", pax_c, strerror(errno)));    }    return 0;  }  fln_w = buf_u.st_size;  pad_y = c3_malloc(buf_u.st_size);  red_w = read(fid_i, pad_y, fln_w);  close(fid_i);  if ( fln_w != red_w ) {    free(pad_y);    c3_assert(0);    return 0;  }  else {    u2_noun pad = u2_ci_bytes(fln_w, (c3_y *)pad_y);    free(pad_y);    return pad;  }}

/* u2_walk_load(): load file or bail.*/u2_nounu2_walk_load(c3_c* pas_c){  struct stat buf_b;  c3_i        fid_i = open(pas_c, O_RDONLY, 0644);  c3_w        fln_w, red_w;  c3_y*       pad_y;  if ( (fid_i < 0) || (fstat(fid_i, &buf_b) < 0) ) {    uL(fprintf(uH, "%s: %s/n", pas_c, strerror(errno)));    return u2_cm_bail(c3__fail);  }  fln_w = buf_b.st_size;  pad_y = malloc(buf_b.st_size);  red_w = read(fid_i, pad_y, fln_w);  close(fid_i);  if ( fln_w != red_w ) {    free(pad_y);    return u2_cm_bail(c3__fail);  }  else {    u2_noun pad = u2_ci_bytes(fln_w, (c3_y *)pad_y);     free(pad_y);    return pad;  }}

/* u3_sist_has(): moronic key-value store existence check.*/ssize_tu3_sist_has(const c3_c* key_c){  c3_c        ful_c[2048];  c3_i        ret_i;  struct stat sat_u;  ret_i = snprintf(ful_c, 2048, "%s/.urb/sis/_%s", u3_Host.dir_c, key_c);  c3_assert(ret_i < 2048);  if ( (ret_i = stat(ful_c, &sat_u)) < 0 ) {    if ( errno == ENOENT ) {      return -1;    }    else {      uL(fprintf(uH, "sist: could not stat %s/n", key_c));      perror("stat");      u3_lo_bail();    }  }  else {    return sat_u.st_size;  }  c3_assert(!"not reached");}

/* _sist_text(): ask for a name string.*/static u3_noun_sist_text(c3_c* pom_c){  c3_c   paw_c[60];  u3_noun say;  uH;  while ( 1 ) {    printf("%s: ", pom_c);    paw_c[0] = 0;    fpurge(stdin);    fgets(paw_c, 59, stdin);    if ( '/n' == paw_c[0] ) {      continue;    }    else {      c3_w len_w = strlen(paw_c);      if ( paw_c[len_w - 1] == '/n' ) {        paw_c[len_w-1] = 0;      }      say = u3i_string(paw_c);      break;    }  }  uL(0);  return say;}

/* _http_conn_new(): create http connection.*/static void_http_conn_new(u3_http *htp_u){  u3_hcon *hon_u = c3_malloc(sizeof(*hon_u));  uv_tcp_init(u3L, &hon_u->wax_u);  c3_w ret_w;  ret_w = uv_accept((uv_stream_t*)&htp_u->wax_u,                    (uv_stream_t*)&hon_u->wax_u);  if (ret_w == UV_EOF)  {    uL(fprintf(uH, "http: accept: ERROR/n"));    uv_close((uv_handle_t*)&hon_u->wax_u, _http_conn_free_early);  }  else {    uv_read_start((uv_stream_t*)&hon_u->wax_u,                  _http_alloc,                  _http_conn_read_cb);    hon_u->coq_l = htp_u->coq_l++;    hon_u->seq_l = 1;    hon_u->ruc_u = 0;    hon_u->req_u = 0;    hon_u->qer_u = 0;    hon_u->htp_u = htp_u;    hon_u->nex_u = htp_u->hon_u;    htp_u->hon_u = hon_u;  }}

/* _term_read_tn_cb(): telnet read callback.*/static void_term_read_tn_cb(uv_stream_t* tcp_u,                   ssize_t      siz_i,                   const uv_buf_t *     buf_u){  u3_utel* pty_u = (u3_utel*)(void*) tcp_u;  u3_lo_open();  {    if ( siz_i == UV_EOF ) {      // nothing    } else if ( siz_i < 0 ) {      uL(fprintf(uH, "term teln: read: %s/n", uv_strerror(siz_i)));      uv_close((uv_handle_t*) tcp_u, _tel_close_cb);      goto err;    }    else {      telnet_receive(pty_u->tel_u, (const telnet_byte*) buf_u->base, siz_i, 0);    }  err:    free(buf_u->base);  }  u3_lo_shut(c3y);}

/* _sist_fast(): offer to save passcode by mug in home directory.*/static void_sist_fast(u3_noun pas, c3_l key_l){  c3_c    ful_c[2048];  c3_c*   hom_c = u3_Host.dir_c;  u3_noun gum   = u3dc("scot", 'p', key_l);  c3_c*   gum_c = u3r_string(gum);  u3_noun yek   = u3dc("scot", 'p', pas);  c3_c*   yek_c = u3r_string(yek);  printf("saving passcode in %s/.urb/code.%s/r/n", hom_c, gum_c);  printf("(for real security, write it down and delete the file...)/r/n");  {    c3_i fid_i;    snprintf(ful_c, 2048, "%s/.urb/code.%s", hom_c, gum_c);    if ( (fid_i = open(ful_c, O_CREAT | O_TRUNC | O_WRONLY, 0600)) < 0 ) {      uL(fprintf(uH, "fast: could not save %s/n", ful_c));      u3_lo_bail();    }    write(fid_i, yek_c, strlen(yek_c));    close(fid_i);  }  free(gum_c);  u3z(gum);  free(yek_c);  u3z(yek);}