/* * PUBLIC: int f_lines __P((SCR *, OPTION *, char *, u_long *)); */ int f_lines( SCR *sp, OPTION *op, char *str, u_long *valp) { /* Validate the number. */ if (*valp < MINIMUM_SCREEN_ROWS) { msgq(sp, M_ERR, "042|Screen lines too small, less than %d", MINIMUM_SCREEN_ROWS); return (1); } /* * !!! * It's not uncommon for allocation of huge chunks of memory to cause * core dumps on various systems. So, we prune out numbers that are * "obviously" wrong. Vi will not work correctly if it has the wrong * number of lines/columns for the screen, but at least we don't drop * core. */ #define MAXIMUM_SCREEN_ROWS 500 if (*valp > MAXIMUM_SCREEN_ROWS) { msgq(sp, M_ERR, "043|Screen lines too large, greater than %d", MAXIMUM_SCREEN_ROWS); return (1); } /* * Set the value, and the related scroll value. If no window * value set, set a new default window. */ o_set(sp, O_LINES, 0, NULL, *valp); if (*valp == 1) { sp->defscroll = 1; if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) || O_VAL(sp, O_WINDOW) > *valp) { o_set(sp, O_WINDOW, 0, NULL, 1); o_set(sp, O_WINDOW, OS_DEF, NULL, 1); } } else { sp->defscroll = (*valp - 1) / 2; if (O_VAL(sp, O_WINDOW) == O_D_VAL(sp, O_WINDOW) || O_VAL(sp, O_WINDOW) > *valp) { o_set(sp, O_WINDOW, 0, NULL, *valp - 1); o_set(sp, O_WINDOW, OS_DEF, NULL, *valp - 1); } } return (0); }
Object Variant::toObjectHelper() const { switch (m_type) { case KindOfUninit: case KindOfNull: return SystemLib::AllocStdClassObject(); case KindOfBoolean: case KindOfInt64: case KindOfDouble: case KindOfStaticString: case KindOfString: case KindOfResource: { auto obj = SystemLib::AllocStdClassObject(); obj->o_set(s_scalar, *this, false); return obj; } case KindOfArray: return ObjectData::FromArray(m_data.parr); case KindOfObject: return m_data.pobj; case KindOfRef: return m_data.pref->var()->toObject(); case KindOfClass: break; } not_reached(); }
/* * PUBLIC: int f_print __P((SCR *, OPTION *, char *, u_long *)); */ int f_print( SCR *sp, OPTION *op, char *str, u_long *valp) { int offset = op - sp->opts; /* Preset the value, needed for reinitialization of lookup table. */ if (offset == O_OCTAL) { if (*valp) O_SET(sp, offset); else O_CLR(sp, offset); } else if (o_set(sp, offset, OS_STRDUP, str, 0)) return(1); /* Reinitialize the key fast lookup table. */ v_key_ilookup(sp); /* Reformat the screen. */ F_SET(sp, SC_SCR_REFORMAT); return (0); }
static Variant HHVM_FUNCTION(imap_check, const Resource& imap_stream) { auto obj = cast<ImapStream>(imap_stream); if (mail_ping(obj->m_stream) == NIL) { return false; } if (obj->m_stream && obj->m_stream->mailbox) { auto ret = SystemLib::AllocStdClassObject(); char date[100]; rfc822_date(date); ret.o_set("Date", String(date, CopyString)); ret.o_set("Driver", String(obj->m_stream->dtb->name, CopyString)); ret.o_set("Mailbox", String(obj->m_stream->mailbox, CopyString)); ret.o_set("Nmsgs", (int64_t)obj->m_stream->nmsgs); ret.o_set("Recent", (int64_t)obj->m_stream->recent); return ret; } return false; }
void conv_init (SCR *orig, SCR *sp) { if (orig != NULL) MEMCPY(&sp->conv, &orig->conv, 1); else { setlocale(LC_ALL, ""); #ifdef USE_WIDECHAR sp->conv.sys2int = cs_char2int; sp->conv.int2sys = cs_int2char; sp->conv.file2int = fe_char2int; sp->conv.int2file = fe_int2char; sp->conv.input2int = ie_char2int; #endif #ifdef USE_ICONV o_set(sp, O_FILEENCODING, OS_STRDUP, nl_langinfo(CODESET), 0); o_set(sp, O_INPUTENCODING, OS_STRDUP, nl_langinfo(CODESET), 0); #endif } }
void Mapping::sort_as(const Mapping & map) { object_list_type n; std::set<Object> t_set(this->_lst.begin(), this->_lst.end()); for(object_list_type::const_iterator i = map._lst.begin(); i != map._lst.end(); ++i) { if(t_set.find(*i) != t_set.end()) { n.push_back(*i); } } std::set<Object> o_set(n.begin(), n.end()); for(object_list_type::const_iterator i = this->_lst.begin(); i != this->_lst.end(); ++i) { if(o_set.find(*i) == o_set.end()) { n.push_back(*i); } else { // key is also in "map" Object & tv = this->at(*i); const Object & ov = map.at(*i); if(tv.is<Mapping>() && ov.is<Mapping>()) { Mapping & tm = reinterpret_cast<Mapping &>(tv.get_object()); const Mapping & om = reinterpret_cast<const Mapping &>(ov.get_object()); tm.sort_as(om); } } } if(this->_lst.size() != n.size()) { std::cerr << "internal error" << std::endl; std::cerr << "this->_lst: " << this->_lst.size() << std::endl; for(object_list_type::const_iterator i = this->_lst.begin(); i != this->_lst.end(); ++i) { std::cerr << " " << i->repr() << std::endl; } std::cerr << "n: " << n.size() << std::endl; for(object_list_type::const_iterator i = n.begin(); i != n.end(); ++i) { std::cerr << " " << i->repr() << std::endl; } std::cout << this->_lst.size() << " " << n.size() << std::endl; throw InternalError(DEBUG_INFO, "key sorting was not successful"); assert(false); } this->_lst = n; }
Array c_DateTime::t___sleep() { o_set(s__date_time, t_format(s_c)); return make_packed_array(s__date_time); }
/* * opts_set -- * Change the values of one or more options. * * PUBLIC: int opts_set __P((SCR *, ARGS *[], const char *)); */ int opts_set(SCR *sp, ARGS **argv, const char *usage) { enum optdisp disp; enum nresult nret; OPTLIST const *op; OPTION *spo; u_long isset, turnoff, value; int ch, equals, nf, nf2, offset, qmark, rval; CHAR_T *endp, *name, *p, *sep; char *p2, *t2; const char *np; size_t nlen; disp = NO_DISPLAY; for (rval = 0; argv[0]->len != 0; ++argv) { /* * The historic vi dumped the options for each occurrence of * "all" in the set list. Puhleeze. */ if (!STRCMP(argv[0]->bp, L("all"))) { disp = ALL_DISPLAY; continue; } /* Find equals sign or question mark. */ for (sep = NULL, equals = qmark = 0, p = name = argv[0]->bp; (ch = *p) != '\0'; ++p) if (ch == '=' || ch == '?') { if (p == name) { if (usage != NULL) msgq(sp, M_ERR, "032|Usage: %s", usage); return (1); } sep = p; if (ch == '=') equals = 1; else qmark = 1; break; } turnoff = 0; op = NULL; if (sep != NULL) *sep++ = '\0'; /* Search for the name, then name without any leading "no". */ if ((op = opts_search(name)) == NULL && name[0] == L('n') && name[1] == L('o')) { turnoff = 1; name += 2; op = opts_search(name); } if (op == NULL) { opts_nomatch(sp, name); rval = 1; continue; } /* Find current option values. */ offset = op - optlist; spo = sp->opts + offset; /* * !!! * Historically, the question mark could be a separate * argument. */ if (!equals && !qmark && argv[1]->len == 1 && argv[1]->bp[0] == '?') { ++argv; qmark = 1; } /* Set name, value. */ switch (op->type) { case OPT_0BOOL: case OPT_1BOOL: /* Some options may not be reset. */ if (F_ISSET(op, OPT_NOUNSET) && turnoff) { msgq_wstr(sp, M_ERR, name, "291|set: the %s option may not be turned off"); rval = 1; break; } /* Some options may not be set. */ if (F_ISSET(op, OPT_NOSET) && !turnoff) { msgq_wstr(sp, M_ERR, name, "313|set: the %s option may never be turned on"); rval = 1; break; } if (equals) { msgq_wstr(sp, M_ERR, name, "034|set: [no]%s option doesn't take a value"); rval = 1; break; } if (qmark) { if (!disp) disp = SELECT_DISPLAY; F_SET(spo, OPT_SELECTED); break; } /* * Do nothing if the value is unchanged, the underlying * functions can be expensive. */ isset = !turnoff; if (!F_ISSET(op, OPT_ALWAYS)) { if (isset) { if (O_ISSET(sp, offset)) break; } else if (!O_ISSET(sp, offset)) break; } /* Report to subsystems. */ if ((op->func != NULL && op->func(sp, spo, NULL, &isset)) || ex_optchange(sp, offset, NULL, &isset) || v_optchange(sp, offset, NULL, &isset) || sp->gp->scr_optchange(sp, offset, NULL, &isset)) { rval = 1; break; } /* Set the value. */ if (isset) O_SET(sp, offset); else O_CLR(sp, offset); break; case OPT_NUM: if (turnoff) { msgq_wstr(sp, M_ERR, name, "035|set: %s option isn't a boolean"); rval = 1; break; } if (qmark || !equals) { if (!disp) disp = SELECT_DISPLAY; F_SET(spo, OPT_SELECTED); break; } if (!ISDIGIT((UCHAR_T)sep[0])) goto badnum; if ((nret = nget_uslong(sp, &value, sep, &endp, 10)) != NUM_OK) { INT2CHAR(sp, name, STRLEN(name) + 1, np, nlen); p2 = msg_print(sp, np, &nf); INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen); t2 = msg_print(sp, np, &nf2); switch (nret) { case NUM_ERR: msgq(sp, M_SYSERR, "036|set: %s option: %s", p2, t2); break; case NUM_OVER: msgq(sp, M_ERR, "037|set: %s option: %s: value overflow", p2, t2); break; case NUM_OK: case NUM_UNDER: abort(); } if (nf) FREE_SPACE(sp, p2, 0); if (nf2) FREE_SPACE(sp, t2, 0); rval = 1; break; } if (*endp && !ISBLANK(*endp)) { badnum: INT2CHAR(sp, name, STRLEN(name) + 1, np, nlen); p2 = msg_print(sp, np, &nf); INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen); t2 = msg_print(sp, np, &nf2); msgq(sp, M_ERR, "038|set: %s option: %s is an illegal number", p2, t2); if (nf) FREE_SPACE(sp, p2, 0); if (nf2) FREE_SPACE(sp, t2, 0); rval = 1; break; } /* Some options may never be set to zero. */ if (F_ISSET(op, OPT_NOZERO) && value == 0) { msgq_wstr(sp, M_ERR, name, "314|set: the %s option may never be set to 0"); rval = 1; break; } /* * Do nothing if the value is unchanged, the underlying * functions can be expensive. */ if (!F_ISSET(op, OPT_ALWAYS) && O_VAL(sp, offset) == value) break; /* Report to subsystems. */ INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen); if ((op->func != NULL && op->func(sp, spo, np, &value)) || ex_optchange(sp, offset, np, &value) || v_optchange(sp, offset, np, &value) || sp->gp->scr_optchange(sp, offset, np, &value)) { rval = 1; break; } /* Set the value. */ if (o_set(sp, offset, 0, NULL, value)) rval = 1; break; case OPT_STR: if (turnoff) { msgq_wstr(sp, M_ERR, name, "039|set: %s option isn't a boolean"); rval = 1; break; } if (qmark || !equals) { if (!disp) disp = SELECT_DISPLAY; F_SET(spo, OPT_SELECTED); break; } /* Check for strings that must have even length */ if (F_ISSET(op, OPT_PAIRS) && STRLEN(sep) & 1) { msgq_wstr(sp, M_ERR, name, "047|set: the %s option must be in two character groups"); rval = 1; break; } /* * Do nothing if the value is unchanged, the underlying * functions can be expensive. */ INT2CHAR(sp, sep, STRLEN(sep) + 1, np, nlen); if (!F_ISSET(op, OPT_ALWAYS) && O_STR(sp, offset) != NULL && !strcmp(O_STR(sp, offset), np)) break; /* Report to subsystems. */ if ((op->func != NULL && op->func(sp, spo, np, NULL)) || ex_optchange(sp, offset, np, NULL) || v_optchange(sp, offset, np, NULL) || sp->gp->scr_optchange(sp, offset, np, NULL)) { rval = 1; break; } /* Set the value. */ if (o_set(sp, offset, OS_STRDUP, np, 0)) rval = 1; break; default: abort(); } } if (disp != NO_DISPLAY) opts_dump(sp, disp); return (rval); }
/* * opts_init -- * Initialize some of the options. * * PUBLIC: int opts_init __P((SCR *, int *)); */ int opts_init(SCR *sp, int *oargs) { ARGS *argv[2], a, b; OPTLIST const *op; u_long isset, v; int cnt, optindx = 0; char *s; CHAR_T b2[1024]; if (sizeof optlist / sizeof optlist[0] - 1 != O_OPTIONCOUNT) { fprintf(stderr, "vi: option table size error (%d != %d)\n", (int)(sizeof optlist / sizeof optlist[0] - 1), O_OPTIONCOUNT); exit(1); } a.bp = b2; b.bp = NULL; a.len = b.len = 0; argv[0] = &a; argv[1] = &b; /* Set numeric and string default values. */ #define OI(indx, str) { \ a.len = STRLEN(str); \ if ((const CHAR_T*)str != b2)/* GCC puts strings in text-space. */\ (void)MEMCPY(b2, str, a.len+1); \ if (opts_set(sp, argv, NULL)) { \ optindx = indx; \ goto err; \ } \ } /* * Indirect global options to global space. Specifically, set up * terminal, lines, columns first, they're used by other options. * Note, don't set the flags until we've set up the indirection. */ if (o_set(sp, O_TERM, 0, NULL, GO_TERM)) goto err; F_SET(&sp->opts[O_TERM], OPT_GLOBAL); if (o_set(sp, O_LINES, 0, NULL, GO_LINES)) goto err; F_SET(&sp->opts[O_LINES], OPT_GLOBAL); if (o_set(sp, O_COLUMNS, 0, NULL, GO_COLUMNS)) goto err; F_SET(&sp->opts[O_COLUMNS], OPT_GLOBAL); if (o_set(sp, O_SECURE, 0, NULL, GO_SECURE)) goto err; F_SET(&sp->opts[O_SECURE], OPT_GLOBAL); /* Initialize string values. */ (void)SPRINTF(b2, SIZE(b2), L("cdpath=%s"), (s = getenv("CDPATH")) == NULL ? ":" : s); OI(O_CDPATH, b2); /* * !!! * Vi historically stored temporary files in /var/tmp. We store them * in /tmp by default, hoping it's a memory based file system. There * are two ways to change this -- the user can set either the directory * option or the TMPDIR environmental variable. */ (void)SPRINTF(b2, SIZE(b2), L("directory=%s"), (s = getenv("TMPDIR")) == NULL ? _PATH_TMP : s); OI(O_TMP_DIRECTORY, b2); OI(O_ESCAPETIME, L("escapetime=1")); OI(O_KEYTIME, L("keytime=6")); OI(O_MATCHCHARS, L("matchchars=()[]{}<>")); OI(O_MATCHTIME, L("matchtime=7")); (void)SPRINTF(b2, SIZE(b2), L("msgcat=%s"), _PATH_MSGCAT); OI(O_MSGCAT, b2); OI(O_REPORT, L("report=5")); OI(O_PARAGRAPHS, L("paragraphs=IPLPPPQPP LIpplpipbp")); (void)SPRINTF(b2, SIZE(b2), L("path=%s"), ""); OI(O_PATH, b2); (void)SPRINTF(b2, SIZE(b2), L("recdir=%s"), _PATH_PRESERVE); OI(O_RECDIR, b2); OI(O_SECTIONS, L("sections=NHSHH HUnhsh")); (void)SPRINTF(b2, SIZE(b2), L("shell=%s"), (s = getenv("SHELL")) == NULL ? _PATH_BSHELL : s); OI(O_SHELL, b2); OI(O_SHELLMETA, L("shellmeta=~{[*?$`'\"\\")); OI(O_SHIFTWIDTH, L("shiftwidth=8")); OI(O_SIDESCROLL, L("sidescroll=16")); OI(O_TABSTOP, L("tabstop=8")); (void)SPRINTF(b2, SIZE(b2), L("tags=%s"), _PATH_TAGS); OI(O_TAGS, b2); /* * XXX * Initialize O_SCROLL here, after term; initializing term should * have created a LINES/COLUMNS value. */ if ((v = (O_VAL(sp, O_LINES) - 1) / 2) == 0) v = 1; (void)SPRINTF(b2, SIZE(b2), L("scroll=%ld"), v); OI(O_SCROLL, b2); /* * The default window option values are: * 8 if baud rate <= 600 * 16 if baud rate <= 1200 * LINES - 1 if baud rate > 1200 * * Note, the windows option code will correct any too-large value * or when the O_LINES value is 1. */ if (sp->gp->scr_baud(sp, &v)) return (1); if (v <= 600) v = 8; else if (v <= 1200) v = 16; else if ((v = O_VAL(sp, O_LINES) - 1) == 0) v = 1; (void)SPRINTF(b2, SIZE(b2), L("window=%lu"), v); OI(O_WINDOW, b2); /* * Set boolean default values, and copy all settings into the default * information. OS_NOFREE is set, we're copying, not replacing. */ for (op = optlist, cnt = 0; op->name != NULL; ++op, ++cnt) switch (op->type) { case OPT_0BOOL: break; case OPT_1BOOL: O_SET(sp, cnt); O_D_SET(sp, cnt); break; case OPT_NUM: o_set(sp, cnt, OS_DEF, NULL, O_VAL(sp, cnt)); break; case OPT_STR: if (O_STR(sp, cnt) != NULL && o_set(sp, cnt, OS_DEF | OS_NOFREE | OS_STRDUP, O_STR(sp, cnt), 0)) goto err; break; default: abort(); } /* * !!! * Some options can be initialized by the command name or the * command-line arguments. They don't set the default values, * it's historic practice. */ for (; *oargs != -1; ++oargs) OI(*oargs, optlist[*oargs].name); #undef OI /* * Inform the underlying screen of the initial values of the * edit options. */ for (op = optlist, cnt = 0; op->name != NULL; ++op, ++cnt) { isset = O_ISSET(sp, cnt); (void)sp->gp->scr_optchange(sp, cnt, O_STR(sp, cnt), &isset); } return (0); err: msgq_wstr(sp, M_ERR, optlist[optindx].name, "031|Unable to set default %s option"); return (1); }
Object hippo_write_result_init(bson_t *reply, bson_error_t *error, mongoc_client_t *client, int server_id, int success, const mongoc_write_concern_t *write_concern) { static Class* c_writeResult; c_writeResult = Unit::lookupClass(s_MongoDriverWriteResult_className.get()); assert(c_writeResult); Object obj = Object{c_writeResult}; MongoDBDriverWriteResultData* wr_data = Native::data<MongoDBDriverWriteResultData>(obj.get()); wr_data->m_client = client; wr_data->m_server_id = server_id; wr_data->m_write_concern = mongoc_write_concern_copy(write_concern); /* Convert the whole BSON reply into a Variant */ Variant v; Array a; hippo_bson_conversion_options_t options = HIPPO_TYPEMAP_DEBUG_INITIALIZER; BsonToVariantConverter convertor(bson_get_data(reply), reply->len, options); convertor.convert(&v); a = v.toArray(); obj->o_set(s_nUpserted, Variant(a[s_nUpserted]), s_MongoDriverWriteResult_className); obj->o_set(s_nMatched, Variant(a[s_nMatched]), s_MongoDriverWriteResult_className); obj->o_set(s_nRemoved, Variant(a[s_nRemoved]), s_MongoDriverWriteResult_className); obj->o_set(s_nInserted, Variant(a[s_nInserted]), s_MongoDriverWriteResult_className); obj->o_set(s_nModified, Variant(a[s_nModified]), s_MongoDriverWriteResult_className); if (write_concern) { Array debugInfoResult = Array::Create(); mongodb_driver_add_write_concern_debug((mongoc_write_concern_t*) write_concern, &debugInfoResult); obj->o_set(s_writeConcern, debugInfoResult, s_MongoDriverWriteConcern_className); } else { obj->o_set(s_writeConcern, Variant(), s_MongoDriverWriteConcern_className); } if (a.exists(s_upserted)) { obj->o_set(s_upsertedIds, a[s_upserted], s_MongoDriverWriteResult_className); } else { Array a = Array::Create(); obj->o_set(s_upsertedIds, a, s_MongoDriverWriteResult_className); } if (a.exists(s_writeErrors)) { Array writeErrors = Array::Create(); for (ArrayIter iter(a[s_writeErrors].toArray()); iter; ++iter) { const Variant& value = iter.second(); static Class* c_writeError; Array a_we = value.toArray(); c_writeError = Unit::lookupClass(s_MongoDriverWriteError_className.get()); assert(c_writeError); Object we_obj = Object{c_writeError}; if (a_we.exists(s_errmsg)) { we_obj->o_set(s_message, a_we[s_errmsg], s_MongoDriverWriteError_className); } if (a_we.exists(s_code)) { we_obj->o_set(s_code, a_we[s_code], s_MongoDriverWriteError_className); } if (a_we.exists(s_index)) { we_obj->o_set(s_index, a_we[s_index], s_MongoDriverWriteError_className); } if (a_we.exists(s_info)) { we_obj->o_set(s_info, a_we[s_info], s_MongoDriverWriteError_className); } writeErrors.append(we_obj); } obj->o_set(s_writeErrors, writeErrors, s_MongoDriverWriteResult_className); } if (a.exists(s_writeConcernErrors)) { Array a_v; a_v = a[s_writeConcernErrors].toArray(); static Class* c_writeConcernError; c_writeConcernError = Unit::lookupClass(s_MongoDriverWriteConcernError_className.get()); assert(c_writeConcernError); Object wce_obj = Object{c_writeConcernError}; if (a_v.exists(0) && a_v[0].isArray()) { Array first_item = a_v[0].toArray(); if (first_item.exists(s_errmsg)) { wce_obj->o_set(s_message, first_item[s_errmsg], s_MongoDriverWriteConcernError_className); } if (first_item.exists(s_code)) { wce_obj->o_set(s_code, first_item[s_code], s_MongoDriverWriteConcernError_className); } if (first_item.exists(s_info)) { wce_obj->o_set(s_info, first_item[s_info], s_MongoDriverWriteConcernError_className); } else { wce_obj->o_set(s_info, Variant(), s_MongoDriverWriteConcernError_className); } obj->o_set(s_writeConcernError, Variant(wce_obj), s_MongoDriverWriteResult_className); } } if (success == 0) { if ((error->domain == MONGOC_ERROR_COMMAND && error->code != MONGOC_ERROR_COMMAND_INVALID_ARG) || error->domain == MONGOC_ERROR_WRITE_CONCERN) { auto bw_exception = MongoDriver::Utils::throwBulkWriteException(error->message); bw_exception->o_set(s_MongoDriverExceptionBulkWriteException_writeResult, obj, MongoDriver::s_MongoDriverExceptionBulkWriteException_className); throw bw_exception; } else { throw MongoDriver::Utils::throwExceptionFromBsonError(error); } } return obj; }
static void _php_imap_add_body(Object &ret, BODY *body, bool do_multipart) { if (body->type <= TYPEMAX) { ret.o_set("type", body->type); } if (body->encoding <= ENCMAX) { ret.o_set("encoding", body->encoding); } if (body->subtype) { ret.o_set("ifsubtype", 1); ret.o_set("subtype", String((const char*)body->subtype, CopyString)); } else { ret.o_set("ifsubtype", 0); } if (body->description) { ret.o_set("ifdescription", 1); ret.o_set("description", String((const char*)body->description, CopyString)); } else { ret.o_set("ifdescription", 0); } if (body->id) { ret.o_set("ifid", 1); ret.o_set("id", String((const char*)body->id, CopyString)); } else { ret.o_set("ifid", 0); } if (body->size.lines) { ret.o_set("lines", (int64_t)body->size.lines); } if (body->size.bytes) { ret.o_set("bytes", (int64_t)body->size.bytes); } if (body->disposition.type) { ret.o_set("ifdisposition", 1); ret.o_set("disposition", String((const char*)body->disposition.type, CopyString)); } else { ret.o_set("ifdisposition", 0); } if (body->disposition.parameter) { PARAMETER *dpar; dpar = body->disposition.parameter; ret.o_set("ifdparameters", 1); Array dparametres(Array::Create()); do { auto dparam = SystemLib::AllocStdClassObject(); dparam.o_set("attribute", String((const char*)dpar->attribute, CopyString)); dparam.o_set("value", String((const char*)dpar->value, CopyString)); dparametres.append(std::move(dparam)); } while ((dpar = dpar->next)); ret.o_set("dparameters", dparametres); } else { ret.o_set("ifdparameters", 0); } PARAMETER *par; Array parametres(Array::Create()); if ((par = body->parameter)) { ret.o_set("ifparameters", 1); do { auto param = SystemLib::AllocStdClassObject(); OBJ_SET_ENTRY(param, par, "attribute", attribute); OBJ_SET_ENTRY(param, par, "value", value); parametres.append(std::move(param)); } while ((par = par->next)); ret.o_set("parameters", parametres); } else { ret.o_set("ifparameters", 0); } if (do_multipart) { /* multipart message ? */ if (body->type == TYPEMULTIPART) { parametres.clear(); PART *part; for (part = body->nested.part; part; part = part->next) { auto param = SystemLib::AllocStdClassObject(); _php_imap_add_body(param, &part->body, do_multipart); parametres.append(std::move(param)); } ret.o_set("parts", parametres); } /* encapsulated message ? */ if ((body->type == TYPEMESSAGE) && (!strcasecmp(body->subtype, "rfc822"))) { body = body->nested.msg->body; parametres.clear(); auto param = SystemLib::AllocStdClassObject(); _php_imap_add_body(param, body, do_multipart); parametres.append(std::move(param)); ret.o_set("parts", parametres); } } }