abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×

dnes 05:55 | Zajímavý článek

Článek na Fedora Magazine krátce představuje programovací jazyk Rust a několik zajímavých v Rustu naprogramovaných terminálových aplikací. Jedná se o alternativu k příkazu grep ripgrep, moderní barevnou alternativu k příkazu ls exa, příkazem cloc inspirovaný tokei a zvířátko v terminálu ternimal.

Ladislav Hagara | Komentářů: 0
včera 23:55 | Zajímavý projekt

Byl spuštěn Humble Classics Return Bundle. Za vlastní cenu lze koupit hry Broken Sword 5 - The Serpent's Curse, Shadowrun Returns a Shadowrun: Dragonfall - Director's Cut. Při nadprůměrné platbě (aktuálně 8,48 $) také Shadowrun: Hong Kong - Extended Edition, Wasteland 2: Director's Cut - Standard Edition, Age of Wonders III a Xenonauts. Při platbě 15 $ a více lze získat navíc Torment: Tides of Numenera a Dreamfall Chapters: The Final Cut Edition.

Ladislav Hagara | Komentářů: 0
včera 00:11 | Bezpečnostní upozornění

Vývojáři linuxové distribuce Mageia na svém blogu upozorňují na narušení bezpečnosti Mageia Identity. Narušitel získal přístup k LDAP databázi a zveřejnil jména uživatelů, jejich emailové adresy a haše hesel. Hesla uživatelů byla resetována.

Ladislav Hagara | Komentářů: 1
20.2. 21:55 | Nová verze

Byla vydána verze 2.0.0 nástroje pro záznam a sdílení terminálových sezení asciinema (GitHub). Z novinek je nutno upozornit na nový zpětně nekompatibilní formát záznamu asciicast v2. S novým formátem si poradí nové verze asciinema-playeru a asciinema-serveru [Hacker News].

Ladislav Hagara | Komentářů: 0
20.2. 05:55 | Zajímavý projekt

Dle příspěvku na blogu zaměstnanců CZ.NIC byl spuštěn ostrý provoz služby Honeypot as a Service (HaaS). Zapojit se může kdokoli. Stačí se zaregistrovat a nainstalovat HaaS proxy, která začne příchozí komunikaci z portu 22 (běžně používaného pro SSH) přeposílat na server HaaS, kde honeypot Cowrie (GitHub) simuluje zařízení a zaznamenává provedené příkazy. Získat lze tak zajímavé informace o provedených útocích. K dispozici jsou globální statistiky.

Ladislav Hagara | Komentářů: 8
20.2. 04:44 | Komunita

Před týdnem společnost Feral Interactive zabývající se vydáváním počítačových her pro operační systémy macOS a Linux oznámila, že pro macOS a Linux vydají hru Rise of the Tomb Raider. Včera společnost oznámila (YouTube), že pro macOS a Linux vydají také hru Total War Saga: Thrones of Britannia. Verze pro Windows by měla vyjít 19. dubna. Verze pro macOS a Linux krátce na to.

Ladislav Hagara | Komentářů: 0
19.2. 21:33 | Nová verze

Byla vydána nová major verze 7.10 svobodného systému pro řízení vztahů se zákazníky (CRM) s názvem SuiteCRM (Wikipedie). Jedná se o fork systému SugarCRM (Wikipedie). Zdrojové kódy SuiteCRM jsou k dispozici na GitHubu pod licencí AGPL.

Ladislav Hagara | Komentářů: 0
19.2. 16:44 | Nová verze

Byla vydána nová verze 0.30 display serveru Mir (Wikipedie) a nová verze 2.31 nástrojů snapd pro práci s balíčky ve formátu snap (Wikipedie). Z novinek Miru vývojáři zdůrazňují vylepšenou podporu Waylandu nebo možnost sestavení a spouštění Miru ve Fedoře. Nová verze snapd umí Mir spouštět jako snap.

Ladislav Hagara | Komentářů: 0
19.2. 14:00 | Komunita

Na Indiegogo běží kampaň na podporu Sway Hackathonu, tj. pracovního setkání klíčových vývojářů s i3 kompatibilního dlaždicového (tiling) správce oken pro Wayland Sway. Cílová částka 1 500 dolarů byla vybrána již za 9 hodin. Nový cíl 2 000 dolarů byl dosažen záhy. Vývojáři přemýšlejí nad dalšími cíli.

Ladislav Hagara | Komentářů: 1
19.2. 11:11 | Nasazení Linuxu

Před dvěma týdny se skupina fail0verflow (Blog, Twitter, GitHub) pochlubila, že se jim podařilo dostat Linux na herní konzoli Nintendo Switch. O víkendu bylo Twitteru zveřejněno další video. Povedlo se jim na Nintendo Switch rozchodit KDE Plasmu [reddit].

Ladislav Hagara | Komentářů: 3
Který webový vyhledávač používáte nejčastěji?
 (2%)
 (28%)
 (62%)
 (2%)
 (3%)
 (0%)
 (1%)
 (1%)
Celkem 421 hlasů
 Komentářů: 35, poslední včera 19:51
    Rozcestník

    PyPy a embedování do C/C++ aplikací

    11.3.2014 17:54 | Přečteno: 682× | poslední úprava: 11.3.2014 17:54

    V práci jsme pro QA oddělení nakódili python plugin pro náš software, aby se už chudáci testeři nemuseli mořit s testováním na základě logů, do kterých jsou vyexportovány všechny data jako ASCII (takový log má klidně přes 100GB zagzippovaný, brr). Tento plugin se osvědčil, ale co si budeme povídat, CPython je pro zpracování velkého množství dat pomalý (a s LuaJIT mě šéf poslal někam ;-) ). Takže zkusíme embedovat PyPy ... no, byla to sranda už jen díky tomu, že jediná "dokumentace" jsou zdrojáky uwsgi PyPy pluginu. Naštěstí se nakonec ukázalo, že embedování PyPy je celkem fajn a následující řádky by měly posloužit jako dokumentace embedování PyPy do C (resp. C++) aplikací.

    Kompilace PyPy

    Ouch, bohužel PyPy v dnešních distribucích není zkompilováno s "--shared", takže je potřeba překompilovat. Naštěstí poslední oficiální release "--shared" podporuje, takže není potřeba řešit mercurial, ani žádné (pochybné) patche :-).

    Více informací o kompilaci (nejedná se o nic složitého, je ovšem potřeba asi 4GB volné ram) a především seznam závislostí zde
    wget https://bitbucket.org/pypy/pypy/downloads/pypy-2.2.1-src.tar.bz2
    tar xf pypy-2.2.1-src.tar.bz2
    cd pypy-2.2.1
    # Pozor, samotná kompilace PyPy vyžaduje PyPy (takže "aptitude install pypy", resp. alternativa pro vaší distribuci)
    ./rpython/bin/rpython -Ojit --shared --gcrootfinder=shadowstack pypy/goal/targetpypystandalone 
    

    A embedujeme ... první příklad

    int main(int argc, char *argv[])
    {
        rpython_startup_code();
        pypy_execute_source("print('Hello World')\n");
        pypy_init_threads();
        return 0;
    }
    
    Stačí zkompilovat a spustit:
    gcc prvni_priklad.c -Lcesta_k_pypy -lpypy-c -o prvni_priklad
    LD_LIBRARY_PATH=cesta_k_pypy ./prvni_priklad
    

    Chybějící PyPy.h (pypy 2.2.1)

    Ve verzích >2.2.1 už PyPy.h bude, takže nebude potřeba takto stahovat.

    Pokud zkusíte překompilovat prvni_priklad.c pomocí g++, kompilace skončí s chybou (gcc -Wall také vypíše ekvivalentní warning), samozřejmě, funkce rpython_startup_code a pypy_execute_source nejsou deklarovány.

    Jak jsem v perexu zmiňoval, embedování PyPy je težce cutting-edge a v posledním stable vydání zatím není PyPy.h (ten byl přidán commitem c4cd6ec).

    Stačí tedy stáhnout PyPy.h z repositáře PyPy a umístit ho do adresáře include/

    cd cesta_k_pypy/include
    wget https://bitbucket.org/pypy/pypy/raw/c4cd6eca9358066571500ac82aaacfdaa3889e8c/include/PyPy.h
    

    Přidejte #include <PyPy.h> na začátek prvni_priklad.c a můžete překompilovat s g++

    g++ -Icesta_k_pypy/include -Wno-write-strings prvni_priklad.c -Lcesta_k_pypy -lpypy-c -o prvni_priklad
    LD_LIBRARY_PATH=cesta_k_pypy ./prvni_priklad
    

    Boilerplate

    Příklad "Hello World" sice funguje hezky, ale pro reálné využití zbývá vyřešit následující:

    1. Načíst python kód ze souboru
    2. Nastavit pypy_home (toto je potřeba, aby správně fungoval import)
    3. Použít CFFI jako mezivrstvu mezi C a Pythonem (pypy_execute_source by měl být zavolán pouze jednou)

    Dále ukážu můj boilerplate pro první dva problémy, CFFI je kapitola sama pro sebe.

    Moje řešení je trochu složitější a navíc je GNU (glibc) a Linux specifické, proto by se na něj neměl nikdo dívat.

    Načtení python kódu ze souboru

    Tady by bylo lepší alternativou použít build systém k vygenerování a hardkódování cesty k .py souboru.

    #include <string.h>
    #include <stdlib.h>
    #include <PyPy.h>
    #include <libgen.h>
    #include <stdio.h>
    
    // caller should free returned pointer to avoid memleaks
    char* change_basename(char* full_path,char* new_basename) {
        char* full_path_copy = strdup(full_path);
        char* dirpath = dirname(full_path_copy);
     
        size_t new_path_len = strlen(dirpath)+1+strlen(new_basename); // +1 because of "/"
        char* new_path = (char*)malloc( new_path_len+1 ); // +1 because of terminating NULL
        memset(new_path, 0, new_path_len+1);
        strcat(new_path, dirpath);
        strcat(new_path, "/");
        strcat(new_path, new_basename);
     
        free(full_path_copy);
        return new_path;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* get_path_to_pyfile() {
        // Linux only
        // http://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe
        // http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor
        char* buf = realpath("/proc/self/exe",NULL);
        if (buf == NULL) {
            return NULL;
        }
        char* py_file = change_basename(buf,"setup.py");
        free(buf);
        return py_file;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* load_python_source(char* filepath) {
        char *buffer;
        long input_file_size;
        FILE *input_file = fopen(filepath, "rb");
        if (input_file == NULL) {
            return NULL;
        }
        fseek(input_file, 0, SEEK_END);
        input_file_size = ftell(input_file);
        rewind(input_file);
        buffer = (char*)malloc(input_file_size * (sizeof(char))+1);
        memset(buffer, 0, input_file_size* (sizeof(char))+1);
        fread(buffer, sizeof(char), input_file_size, input_file);
        fclose(input_file);
        return buffer;
    }
    
    int main(int argc, char *argv[])
    {
        // PyPy initialization
     
        char* py_file = get_path_to_pyfile();
        if (!py_file) {
            printf("Error determining path to the  python setup file (setup.py)\n");
            exit(1);
        }
        char* buffer = load_python_source(py_file);
        if (!buffer) {
            printf("Error opening python setup file (setup.py)\n");
            exit(1);
        }
     
        // actual pypy initialization
        rpython_startup_code();
        pypy_execute_source( buffer );
        pypy_init_threads();
       
        // free stuff
        if (py_file != NULL) {
            free(py_file);
        }
        if (buffer != NULL) {
            free(buffer);
        }
        // end of PyPy initialization
    
        return 0;
    }
    

    Nastavení pypy_home

    Aby správně fungoval import, je potřeba před zavoláním funkce pypy_execute_source zavolat pypy_setup_home.

    Funkci pypy_setup_home je potřeba předat cestu k lib_pypy. Nenašel jsem způsob jak tuto cestu najít čistým způsobem (např. pomocí pkg-config) a proto následující glibc specifický hack.

    #if !(_GNU_SOURCE)
    #define _GNU_SOURCE
    #endif
     
    #include <stdio.h>
    #include <dlfcn.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <libgen.h>
    #include <PyPy.h>
    
    // caller should free returned pointer to avoid memleaks
    char* change_basename(char* full_path,char* new_basename) {
        char* full_path_copy = strdup(full_path);
        char* dirpath = dirname(full_path_copy);
     
        size_t new_path_len = strlen(dirpath)+1+strlen(new_basename); // +1 because of "/"
        char* new_path = (char*)malloc( new_path_len+1 ); // +1 because of terminating NULL
        memset(new_path, 0, new_path_len+1);
        strcat(new_path, dirpath);
        strcat(new_path, "/");
        strcat(new_path, new_basename);
     
        free(full_path_copy);
        return new_path;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* guess_pypyhome() {
        // glibc-only (dladdr is why we #define _GNU_SOURCE)
        // http://stackoverflow.com/questions/1681060/library-path-when-dynamically-loaded
        Dl_info info;
        void *_rpython_startup_code;
        _rpython_startup_code = dlsym(NULL,"rpython_startup_code");
        if (_rpython_startup_code == NULL) {
            return NULL;
        }
        if (dladdr(_rpython_startup_code, &info) != 0) {
            const char* lib_path = info.dli_fname;
            char* lib_realpath = realpath(lib_path, NULL);
            if (lib_realpath == NULL) {
                return NULL;
            }
            char* pypy_home = change_basename(lib_realpath,"pypy");
            free(lib_realpath);
            return pypy_home;
        }
        return NULL;
    }
    
    int main(int argc, char *argv[])
    {
        // PyPy initialization
        
        char* pypy_home = getenv("PYPY_HOME");
        int free_pypy_home = 0;
        if (pypy_home == NULL) {
            pypy_home = guess_pypyhome();
            free_pypy_home = 1;
        }
        if (!pypy_home) {
            printf("PYPY_HOME was not specified and PYPY_HOME autodetection failed\n");
            exit(1);
        }
        
        // actual pypy initialization
        rpython_startup_code();
        pypy_setup_home(pypy_home,1);
        pypy_execute_source("import cffi; print('Hello World')\n");
        pypy_init_threads();
       
        // free stuff
        if (free_pypy_home == 1 && pypy_home != NULL) {
            free(pypy_home);
        }
        return 0;
    }
    

    Také je potřeba linkovat oproti dl.

    g++ -Wno-write-strings priklad-pypy_set_home.c -Lcesta_k_pypy -lpypy-c -ldl -Icesta_k_pypy/include -o priklad-pypy_set_home
    

    CFFI

    Interface mezi PyPy a C kódem je nejlepší řešit pomocí CFFI (dokumentace). Funkci pypy_execute_source předáme python kód, který může nadefinovat callbacky apod.

    Kompletí příklad

    A nakonec kompletní ukázka jak nadefinovat a volat callback v PyPy (python kód) z C.

    priklad-pypy.c

    #if !(_GNU_SOURCE)
    #define _GNU_SOURCE
    #endif
    
    #include <stdio.h>
    #include <libgen.h>
    #include <dlfcn.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <PyPy.h>
    
    // caller should free returned pointer to avoid memleaks
    char* change_basename(char* full_path,char* new_basename) {
        char* full_path_copy = strdup(full_path);
        char* dirpath = dirname(full_path_copy);
    
        size_t new_path_len = strlen(dirpath)+1+strlen(new_basename); // +1 because of "/"
        char* new_path = (char*)malloc( new_path_len+1 ); // +1 because of terminating NULL
        memset(new_path, 0, new_path_len+1);
        strcat(new_path, dirpath);
        strcat(new_path, "/");
        strcat(new_path, new_basename);
    
        free(full_path_copy);
        return new_path;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* guess_pypyhome() {
        // glibc-only (dladdr is why we #define _GNU_SOURCE)
        // http://stackoverflow.com/questions/1681060/library-path-when-dynamically-loaded
        Dl_info info;
        void *_rpython_startup_code;
        _rpython_startup_code = dlsym(NULL,"rpython_startup_code");
        if (_rpython_startup_code == NULL) {
            return NULL;
        }
        if (dladdr(_rpython_startup_code, &info) != 0) {
            const char* lib_path = info.dli_fname;
            char* lib_realpath = realpath(lib_path, NULL);
            if (lib_realpath == NULL) {
                return NULL;
            }
            char* pypy_home = change_basename(lib_realpath,"pypy");
            free(lib_realpath);
            return pypy_home;
        }
        return NULL;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* load_python_source(char* filepath) {
        char *buffer;
        long input_file_size;
        FILE *input_file = fopen(filepath, "rb");
        if (input_file == NULL) {
            return NULL;
        }
        fseek(input_file, 0, SEEK_END);
        input_file_size = ftell(input_file);
        rewind(input_file);
        buffer = (char*)malloc(input_file_size * (sizeof(char))+1);
        memset(buffer, 0, input_file_size* (sizeof(char))+1);
        fread(buffer, sizeof(char), input_file_size, input_file);
        fclose(input_file);
        return buffer;
    }
    
    // caller should free returned pointer to avoid memleaks
    // returns NULL on error
    char* get_path_to_pyfile() {
        // Linux only
        // http://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe 
        // http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor
        char* buf = realpath("/proc/self/exe",NULL);
        if (buf == NULL) {
            return NULL;
        }
        char* py_file = change_basename(buf,"setup.py");
        free(buf);
        return py_file;
    }
    
    void (*callback)(long);
    
    int main(int argc, char *argv[])
    {
        // PyPy initialization
    
        // prepare stuff
        char* pypy_home = getenv("PYPY_HOME");
        int free_pypy_home = 0;
        if (pypy_home == NULL) {
            pypy_home = guess_pypyhome();
            free_pypy_home = 1;
        }
        if (!pypy_home) {
            printf("PYPY_HOME was not specified and PYPY_HOME autodetection failed\n");
            exit(1);
        }
        char* py_file = get_path_to_pyfile();
        if (!py_file) {
            printf("Error determining path to the  python setup file (setup.py)\n");
            exit(1);
        }
        char* buffer = load_python_source(py_file);
        if (!buffer) {
            printf("Error opening python setup file (setup.py)\n");
            exit(1);
        }
    
        // actual pypy initialization
        rpython_startup_code();
        pypy_setup_home(pypy_home,1);
        pypy_execute_source( buffer );
        pypy_init_threads(); 
        // pypy_thread_attach(); // if multithreaded, call this in every thread which is calling into pypy
        
        // end of PyPy initialization
    
        for (int i=0; i<10; i++) {    
            callback(42);
        }
    
        // free stuff
        if (free_pypy_home == 1 && pypy_home != NULL) {
            free(pypy_home);
        }
        if (py_file != NULL) {
            free(py_file);
        }
        if (buffer != NULL) {
            free(buffer);
        }
    
        return 0;
    }
    

    Aby fungovaly callbacky s CFFI je potřeba překompilovat s flagem -export-dynamic

    g++ -Wno-write-strings priklad-pypy.c -Lcesta_k_pypy -lpypy-c -ldl -Icesta_k_pypy/include -o priklad-pypy -export-dynamic
    

    setup.py:

    V tomto příkladu mám kód přímo v callback funkci v setup.py, v reálném nasazení by setup.py fungoval pouze jako vrstva mezi C a pythonem a volal uživatelský kód v jiném modulu, který by už o žádném C nebo CFFI nevěděl.

    import os
    if "PYTHONPATH" in os.environ:
        import sys
        paths = os.environ["PYTHONPATH"].split(":")
        paths.reverse()
        for p in paths:
            sys.path.insert(0,p)
    
    import cffi
    ffi = cffi.FFI()
    ffi.cdef('void (*callback)(long);')
    lib = ffi.verify('void (*callback)(long);')
    def callback(i):
        print("yaay: %d" % i)
    cb = ffi.callback('void(long)',callback)
    lib.callback = cb
    
    LD_LIBRARY_PATH=cesta_k_pypy ./priklad-pypy
    

    Závěr

    Na první pohled se může zdát, že embedování PyPy do C je celkem složité, není tomu tak (vždyť kompletní příklad má kolem 150 řádků C kódu a většina z toho je copy&paste boilerplate). V mých (jednoduchých) testech jsem na problémy nenarazil, ale je potřeba mít na paměti, že embedování PyPy je těžce hipster feature.

           

    Hodnocení: 100 %

            špatnédobré        

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    Komentáře

    Vložit další komentář

    11.3.2014 18:31 Radek Podgorny | skóre: 16
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    k cemu konkretne ze to pouzivate? nejak v tom nevidim smysl.

    bez tech callbacku to vlastne jen imituje "vstupni" cast normalniho interpretu. stejny by bylo rovnou spustit 'pypy soubor.py', ne?

    a callbacky je mozne nacist z toho pythonu pomoci ctypes (nebo toho cffi?) a volat je primo (tedy jaksi embedovat c do pythonu), ne?

    nebo jsem uplne mimo? ;-)
    11.3.2014 18:52 luv | skóre: 18 | blog: luv
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    Napriklad mas obrovskou C++ aplikaci a chces malou cast z ni implementovat v pythonu (resp. umoznit nekomu jinemu jeji rozsirovani pomoci pythonu). Klasika, napriklad skriptovani her. Tady resim jak pouzit misto CPythonu PyPy, protoze je mnohem rychlejsi (JIT).
    11.3.2014 19:51 psio
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    Byly by nejake benchmarky, ze se ty komplikace s PyPy vyplatili ? Ja mam bohuzel zkusenost, ze pro nas to byla ztrata casu a na testech nam to davalo +/- stejne vysledky jako klasicky CPython a ne jenom u kodu, kterej byl brzdenej komunikaci s databazi. S rychlosti behu LuaJIT 2.x se to vubec neda srovnavat. To uz je fakt lepsi to nejnutnejsi nakodit v C, Python ma k dispozici celkem slusny rozhrani jako cffi. Alternativne v Cythonu, pokud lze resit pouzitim ceckovych datovych typu.

    11.3.2014 20:44 luv | skóre: 18 | blog: luv
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    Zrovna u tohohle jsme zkoncili zpatky u CPythonu (+posunuti vice kodu do C++) ;-). Protoze co se tyka interface python<->c++ tak (muj) cffi kod + pypy byl pomalejsi nez CPython a jeho nativni API. A samotne testy, ktere jsou napsane v pythonu jsou velice light-weight, takze PyPy vlastne moc nepomuze, ale v jinych situacich (pokud chcete embedovat narocnejsi python kod) verim ze pomuze dost - na LuaJIT to vykonem samozrejme mit nebude.

    Na druhou stranu, kolegovy jeho kod bezi nekolikanasobne rychleji jen diky tomu ze ho pusti pomoci pypy misto cpythonu (a navic nepotreboval embedovat, takze zadne komplikace) ... takze fakt zalezi jak kdy.
    Jardík avatar 12.3.2014 00:21 Jardík | skóre: 40 | blog: jarda_bloguje
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    char* change_basename(char* full_path,char* new_basename) {
        char* full_path_copy = strdup(full_path);
        char* dirpath = dirname(full_path_copy);
      
        size_t new_path_len = strlen(dirpath)+1+strlen(new_basename); // +1 because of "/"
        char* new_path = (char*)malloc( new_path_len+1 ); // +1 because of terminating NULL
        memset(new_path, 0, new_path_len+1);
        strcat(new_path, dirpath);
        strcat(new_path, "/");
        strcat(new_path, new_basename);
      
        free(full_path_copy);
        return new_path;
    }
    
    Proč full_patch a new_basename není char const*? Žádný z nich nemodifikujete a pro full_patch stejně děláte kopii. Ten memset je totálně zbytečnej, použití strcat, když už znáte délky řetězců z předchozích volání, je pitomost. No ono i ta zbytečná kopie full_path je pitomost daná použití stupidní fce, která se nehodí.
    Věřím v jednoho Boha.
    12.3.2014 01:10 luv | skóre: 18 | blog: luv
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    Proč full_patch a new_basename není char const*?
    Protoze jsem maslo, tohle si fixnu.
    Ten memset je totálně zbytečnej
    Ano je, ale nicemu nevadi protoze se zavola behem behu programu asi dvakrat. Btw. kdybych ho jen vyhodil, tak ten c string nekonci \0. Ale chapu jak to myslis.
    použití strcat, když už znáte délky řetězců z předchozích volání, je pitomost.
    hmmm?
    No ono i ta zbytečná kopie full_path je pitomost daná použití stupidní fce
    Co jsem mel pouzit misto dirname? :-/
    Jardík avatar 12.3.2014 03:29 Jardík | skóre: 40 | blog: jarda_bloguje
    Rozbalit Rozbalit vše Re: PyPy a embedování do C/C++ aplikací
    Btw. kdybych ho jen vyhodil, tak ten c string nekonci \0
    Stačí ti nastavit první byte na 0 pro první strcat(), ten ti nakonec dá další nulu pro další strcat(), ... ale jestli to voláš 2x, ok.
    hmmm?
    char* full_path_copy = strdup(full_path);
    char* dirpath = dirname(full_path_copy);
    
    size_t dirpath_len = strlen(dirpath);
    size_t new_basename_len = strlen(new_basename);
    size_t new_path_len = dirpath_len + new_basename_len + 1;
    
    char* new_path = (char*)malloc( new_path_len+1 );
    memcpy(new_path, dirpath, dirpath_len);
    new_path[dirpath_len] = '/';
    memcpy(new_path+dirpath_len+1, new_basename, new_basename_len);
    new_path[new_path_len] = 0;
    free(full_path_copy);
    return new_path;
    
    Nebo třeba použít stpcpy (POSIX only), ale memcpy je lepší, když už délku znám.
    Co jsem mel pouzit misto dirname?
    Nějakej strchr() by mohl stačit. Problém s dirname je ten, že modifikuje řetězec a musíš tedy alokovat kopii, následně alokuješ další pro výsledný řetězec. To když je pak třeba v cyklu, tak to může být ee.
    Věřím v jednoho Boha.

    Založit nové vláknoNahoru

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.