*/ REBINT Emit_Integer(REBYTE *buf, REBI64 val)
/*
***********************************************************************/
{
INT_TO_STR(val, buf);
return LEN_BYTES(buf);
}
*/ REBOOL Cloak(REBOOL decode, REBYTE *cp, REBCNT dlen, REBYTE *kp, REBCNT klen, REBFLG as_is)
/*
** Simple data scrambler. Quality depends on the key length.
** Result is made in place (data string).
**
** The key (kp) is passed as a REBVAL or REBYTE (when klen is !0).
**
***********************************************************************/
{
REBCNT i, n;
REBYTE src[20];
REBYTE dst[20];
if (dlen == 0) return TRUE;
// Decode KEY as VALUE field (binary, string, or integer)
if (klen == 0) {
REBVAL *val = (REBVAL*)kp;
REBSER *ser;
switch (VAL_TYPE(val)) {
case REB_BINARY:
kp = VAL_BIN_DATA(val);
klen = VAL_LEN(val);
break;
case REB_STRING:
ser = Temp_Bin_Str_Managed(val, &i, &klen);
kp = BIN_SKIP(ser, i);
break;
case REB_INTEGER:
INT_TO_STR(VAL_INT64(val), dst);
klen = LEN_BYTES(dst);
as_is = FALSE;
break;
}
if (klen == 0) return FALSE;
}
if (!as_is) {
for (i = 0; i < 20; i++) src[i] = kp[i % klen];
SHA1(src, 20, dst);
klen = 20;
kp = dst;
}
if (decode)
for (i = dlen-1; i > 0; i--) cp[i] ^= cp[i-1] ^ kp[i % klen];
// Change starting byte based all other bytes.
n = 0xa5;
for (i = 1; i < dlen; i++) n += cp[i];
cp[0] ^= (REBYTE)n;
if (!decode)
for (i = 1; i < dlen; i++) cp[i] ^= cp[i-1] ^ kp[i % klen];
return TRUE;
}
*/ REBYTE *Form_Integer(REBYTE *buf, REBI64 val)
/*
** Form standard REBOL integer value (32 or 64).
** Make sure you have room in your buffer before calling this!
**
***********************************************************************/
{
INT_TO_STR(val, buf);
return buf+LEN_BYTES(buf);
}
//
// Cloak: C
//
// Simple data scrambler. Quality depends on the key length.
// Result is made in place (data string).
//
// The key (kp) is passed as a REBVAL or REBYTE (when klen is !0).
//
REBOOL Cloak(REBOOL decode, REBYTE *cp, REBCNT dlen, REBYTE *kp, REBCNT klen, REBOOL as_is)
{
REBCNT i, n;
REBYTE src[20];
REBYTE dst[20];
if (dlen == 0) return TRUE;
// Decode KEY as VALUE field (binary, string, or integer)
if (klen == 0) {
REBVAL *val = (REBVAL*)kp;
REBSER *ser;
switch (VAL_TYPE(val)) {
case REB_BINARY:
kp = VAL_BIN_AT(val);
klen = VAL_LEN_AT(val);
break;
case REB_STRING:
ser = Temp_Bin_Str_Managed(val, &i, &klen);
kp = BIN_AT(ser, i);
break;
case REB_INTEGER:
INT_TO_STR(VAL_INT64(val), dst);
klen = LEN_BYTES(dst);
as_is = FALSE;
break;
}
if (klen == 0) return FALSE;
}
if (!as_is) {
for (i = 0; i < 20; i++) src[i] = kp[i % klen];
SHA1(src, 20, dst);
klen = 20;
kp = dst;
}
if (decode)
for (i = dlen-1; i > 0; i--) cp[i] ^= cp[i-1] ^ kp[i % klen];
// Change starting byte based all other bytes.
n = 0xa5;
for (i = 1; i < dlen; i++) n += cp[i];
cp[0] ^= (REBYTE)n;
if (!decode)
for (i = 1; i < dlen; i++) cp[i] ^= cp[i-1] ^ kp[i % klen];
return TRUE;
}
STOID Mold_Logic(REB_MOLD *mold, REBVAL *value)
{
REBYTE buf[20];
Pre_Mold(value, mold);
INT_TO_STR(VAL_LOGIC(value), buf);
Append_Bytes(mold->series, buf);
Append_Byte(mold->series, ' ');
old_Block_Series(mold, BLK_HEAD(VAL_LOGIC_WORDS(value)), 0);
End_Mold(mold);
}
REBINT Emit_Decimal(REBYTE *cp, REBDEC d, REBFLG trim, REBYTE point, REBINT decimal_digits) {
REBYTE *start = cp, *sig, *rve;
REBINT e, sgn, digits_obtained;
/* sanity checks */
if (decimal_digits < MIN_DIGITS) decimal_digits = MIN_DIGITS;
else if (decimal_digits > MAX_DIGITS) decimal_digits = MAX_DIGITS;
sig = (REBYTE *) dtoa (d, 0, decimal_digits, &e, &sgn, (char **) &rve);
digits_obtained = rve - sig;
/* handle sign */
if (sgn) *cp++ = '-';
if (trim == DEC_MOLD_PERCENT) e += 2;
if ((e > decimal_digits) || (e <= -6)) {
/* e-format */
*cp++ = *sig++;
/* insert the radix point */
*cp++ = point;
/* insert the rest */
memcpy(cp, sig, digits_obtained - 1);
cp += digits_obtained - 1;
} else if (e > 0) {
if (e <= digits_obtained) {
/* insert digits preceding point */
memcpy (cp, sig, e);
cp += e;
sig += e;
*cp++ = point;
/* insert digits following point */
memcpy(cp, sig, digits_obtained - e);
cp += digits_obtained - e;
} else {
/* insert all digits obtained */
memcpy (cp, sig, digits_obtained);
cp += digits_obtained;
/* insert zeros preceding point */
memset (cp, '0', e - digits_obtained);
cp += e - digits_obtained;
*cp++ = point;
}
e = 0;
} else {
*cp++ = '0';
*cp++ = point;
memset(cp, '0', -e);
cp -= e;
memcpy(cp, sig, digits_obtained);
cp += digits_obtained;
e = 0;
}
// Add at least one zero after point (unless percent or pair):
if (*(cp - 1) == point) {if (trim) cp--; else *cp++ = '0';}
// Add E part if needed:
if (e) {
*cp++ = 'e';
INT_TO_STR(e - 1, cp);
cp = strchr(cp, 0);
}
if (trim == DEC_MOLD_PERCENT) *cp++ = '%';
*cp = 0;
return cp - start;
}
//
// Form_Integer: C
//
// Form standard REBOL integer value (32 or 64).
// Make sure you have room in your buffer before calling this!
//
REBYTE *Form_Integer(REBYTE *buf, REBI64 val)
{
INT_TO_STR(val, buf);
return buf+LEN_BYTES(buf);
}
static int fill_iso8601_timestamp(int32_t timestamp, int32_t milli,
char* buffer, int* length) {
int16_t year;
int8_t month, month_length;
int32_t day;
int8_t hour, minute, second;
if (*length < SIZE_ISO_8601) {
*length = SIZE_ISO_8601;
return E_BUFFER_TOO_SMALL;
}
second = timestamp % 60;
timestamp /= 60; // now it is minutes
minute = timestamp % 60;
timestamp /= 60; // now it is hours
hour = timestamp % 24;
timestamp /= 24; // now it is days
year = 0;
day = 0;
while ((day += days_in_year(year)) <= timestamp) {
year++;
}
day -= days_in_year(year);
timestamp -= day; // now it is days in this year, starting at 0
day = 0;
month_length = 0;
for (month = 0; month < 12; month++) {
if (month == 1) {
// February
month_length = is_leap_year(year) ? 29 : 28;
} else {
month_length = MONTH_DAYS[month];
}
if (timestamp >= month_length) {
timestamp -= month_length;
} else {
break;
}
}
year = 1970 + year;
month++; // offset by 1
day = timestamp + 1;
int i = 0, j = 0;
// NOTE: It seems the snprintf implementation in Arduino has bugs,
// we have to manually piece the string together here.
#define INT_TO_STR(v_, width_) \
for (j = 0; j < (width_); j++) { \
buffer[i + (width_) - 1 - j] = '0' + ((v_) % 10); \
(v_) /= 10; \
} \
i += (width_)
INT_TO_STR(year, 4);
buffer[i++] = '-';
INT_TO_STR(month, 2);
buffer[i++] = '-';
INT_TO_STR(day, 2);
buffer[i++] = 'T';
INT_TO_STR(hour, 2);
buffer[i++] = ':';
INT_TO_STR(minute, 2);
buffer[i++] = ':';
INT_TO_STR(second, 2);
buffer[i++] = '.';
INT_TO_STR(milli, 3);
buffer[i++] = 'Z';
buffer[i++] = '\0';
#undef INT_TO_STR
*length = i;
return E_OK;
}
