Vyšlo Pharo 12.0, programovací jazyk a vývojové prostředí s řadou pokročilých vlastností. Krom tradiční nadílky oprav přináší nový systém správy ladících bodů, nový způsob definice tříd, prostor pro objekty, které nemusí procházet GC a mnoho dalšího.
Microsoft zveřejnil na GitHubu zdrojové kódy MS-DOSu 4.0 pod licencí MIT. Ve stejném repozitáři se nacházejí i před lety zveřejněné zdrojové k kódy MS-DOSu 1.25 a 2.0.
Canonical vydal (email, blog, YouTube) Ubuntu 24.04 LTS Noble Numbat. Přehled novinek v poznámkách k vydání a také příspěvcích na blogu: novinky v desktopu a novinky v bezpečnosti. Vydány byly také oficiální deriváty Edubuntu, Kubuntu, Lubuntu, Ubuntu Budgie, Ubuntu Cinnamon, Ubuntu Kylin, Ubuntu MATE, Ubuntu Studio, Ubuntu Unity a Xubuntu. Jedná se o 10. LTS verzi.
Na YouTube je k dispozici videozáznam z včerejšího Czech Open Source Policy Forum 2024.
Fossil (Wikipedie) byl vydán ve verzi 2.24. Jedná se o distribuovaný systém správy verzí propojený se správou chyb, wiki stránek a blogů s integrovaným webovým rozhraním. Vše běží z jednoho jediného spustitelného souboru a uloženo je v SQLite databázi.
Byla vydána nová stabilní verze 6.7 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 124. Přehled novinek i s náhledy v příspěvku na blogu. Vypíchnout lze Spořič paměti (Memory Saver) automaticky hibernující karty, které nebyly nějakou dobu používány nebo vylepšené Odběry (Feed Reader).
OpenJS Foundation, oficiální projekt konsorcia Linux Foundation, oznámila vydání verze 22 otevřeného multiplatformního prostředí pro vývoj a běh síťových aplikací napsaných v JavaScriptu Node.js (Wikipedie). V říjnu se verze 22 stane novou aktivní LTS verzí. Podpora je plánována do dubna 2027.
Byla vydána verze 8.2 open source virtualizační platformy Proxmox VE (Proxmox Virtual Environment, Wikipedie) založené na Debianu. Přehled novinek v poznámkách k vydání a v informačním videu. Zdůrazněn je průvodce migrací hostů z VMware ESXi do Proxmoxu.
R (Wikipedie), programovací jazyk a prostředí určené pro statistickou analýzu dat a jejich grafické zobrazení, bylo vydáno ve verzi 4.4.0. Její kódové jméno je Puppy Cup.
IBM kupuje společnost HashiCorp (Terraform, Packer, Vault, Boundary, Consul, Nomad, Waypoint, Vagrant, …) za 6,4 miliardy dolarů, tj. 35 dolarů za akcii.
Řešení dotazu:
uint16_t temparr[]
a ve smyčce do něj ukládat části původního pole a ty zapisovat?
#define TA_LEN 1000;
static inline void zkonvertuj_dalsi_cast_pole(uint16_ * temparr, uint32_t * array, size_t index, size_t TA_LEN)
{
...
}
void foo(void)
{
FILE file;
size_t index = 0;
uint16_t temparr[TA_LEN];
...
while(pole_jeste_neni_zpracovano)
{
zkonvertuj_dalsi_cast_pole(temparr, array, index, TA_LEN);
fwrite(temparr, sizeof(temparr), 1, file);
index += TA_LEN;
}
...
}
V příkladu samozřejmě není ošetřená případná chyba fwrite()
nebo stav kdy TA_LEN není soudělné s počtem prvků pole array[]
uint32_t array[10000000]; uint32_t *index; size_t i; for(index=array, i=0; i <= 10000000; i++, index++) { fwrite(*((uint16_t) index), sizefof(uint16_t), 1, FD); } /* este raz a citatelnejsie */ uint32_t array[10000000]; uint32_t *index; uint16_t u16; size_t i; for(index=array, i=0; i <= 10000000; i++, index++) { u16=(uint16_t) *index; fwrite(u16, sizefof(uint16_t), 1, FD); }Ono takto definovane by sa vo funkcie malo vytvarat na zasobniku. A to nemusi az tak v tentokrat u Andruido prospievat. Nechces pripadne allokovat pre beh programu tuto pamet cez malloc.
Ůůůfff. Tohle ale mlčky předpokládá Little Endian, kde se dá jenom tak přetypovat uint32_t*
na uint16_t*
a ty dolní byty tam budou. Na Big Endian tam bude všude nula (horní byty).
Ne, beru zpět, neumím číst. Pointer se tady nepřetypuje, takže je to OK.
Dá se to nějak provést bez tvorby ještě jednoho pole uint16_t o stejné velikosti?
Ano. Například nějak tahle (convert_in_place(...)
):
#include <errno.h> #include <fcntl.h> #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> static const size_t SIZE = 100000; typedef uint16_t narrow_array_t[SIZE]; typedef uint32_t wide_array_t[SIZE]; typedef uint16_t (*narrow_array_ptr)[SIZE]; typedef uint32_t (*wide_array_ptr)[SIZE]; //////////////////////////////////////////////////////////////////////////////// static narrow_array_ptr convert_in_place(const wide_array_ptr wide_array) { const uint32_t *source = *wide_array; uint16_t *dest = (uint16_t*)source; const uint16_t *const end = dest + SIZE; while (dest < end) *dest++ = *source++; return realloc(wide_array, sizeof(narrow_array_t)); // free extra memory // return (narrow_array_ptr)wide_array; // keep extra memory } //////////////////////////////////////////////////////////////////////////////// static int dump_array_to_file(const char *const file_name, const narrow_array_ptr narrow_array) { const int output = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); if (output == -1) { fputs(strerror(errno), stderr); return EXIT_FAILURE; } int result = EXIT_SUCCESS; size_t to_write = sizeof(narrow_array_t); uint8_t *buffer = (uint8_t*)narrow_array; while (to_write) { const ssize_t written = write(output, buffer, to_write); if (written == -1) { result = EXIT_FAILURE; fputs(strerror(errno), stderr); break; } buffer += written; to_write -= written; } if (close(output) == -1) { fputs(strerror(errno), stderr); return EXIT_FAILURE; } return result; } int main() { // Allocate and populate an array of 32-bit integers. uint32_t (*const wide_array)[SIZE] = malloc(sizeof(wide_array_t)); if (!wide_array) { fputs(strerror(errno), stderr); return EXIT_FAILURE; } for (size_t i = 0; i < SIZE; ++i) (*wide_array)[i] = i % 16384; // Compact 32-bit integers into 16-bit integers in-place. uint16_t (*const narrow_array)[SIZE] = convert_in_place(wide_array); // Write compacted array to standard output, just for fun. const uint16_t *const end = *narrow_array + SIZE; for (uint16_t *number = *narrow_array; number < end; ++number) printf("%d, ", *number); // unchecked! putchar('\n'); // unchecked! // Write the compacted array into a binary file. int result = dump_array_to_file("/tmp/output", narrow_array); free(narrow_array); return result; }
Pokud se nepletu, tento^^^ kód nezávisí na endianness, protože nedělá žádné podivné bitové operace. Tedy na BE vyrobí binární soubor v BE, na LE vyrobí binární soubor v LE. (A pokud se pletu, hned se mi bude někdo posmívat, takže dobře mi tak.)
Nebo přesvědčit fwrite, aby ukládal jen posledních 16bitů z každého prvku a to ostatní ignoroval (tedy ani nevyplňoval nulama).
Ano, tohle by taky šlo, ale musel by se ten fwrite()
(nebo write()
) volat SIZE
-krát, vždycky na ty 2 byty, což by bylo celkem ošklivé a navíc by to bylo závislé na endianness, tj. muselo by se podle LE/BE správně určit, které 2 byty vypsat.
uint16_t *tmp=(uint16_t*)array; for (i=0;i<10000000;i++,tmp++) *tmp=array[i]; fwrite(array,10000000,sizeof(uint16_t),FD);Načo si tam písal tých ostatných 76 riadkov?
Tiskni Sdílej: