CHARGER UNE POLICE DEPUIS UN FICHIER OU UNE RESSOURCE (WIN32)

Commentaire de MuPuF le 03/08/2006 01:25:27

oh super !, merci, ça va vraiment me servir, je fais actuelle une classe pour gerer les skins, ta source va apporter un réel plus !

La source compile sans probleme et fonctionne parfaitement.

Encore une fois merci ;-)

Commentaire de MuPuF le 03/08/2006 01:30:11

hey hey vecchiodamus ;-)

Commentaire de mogwai93 le 03/08/2006 08:29:37

Question par rapport à DevCpp :
ca compile mais en remplacant :

#ifdef _DEBUG
int main()
#else
#pragma comment(linker, "/entry:myWinMain")
int __stdcall myWinMain()
#endif

par :
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   LPSTR lpCmdLine, int nCmdShow)

et
#ifdef _DEBUG
  return (int)msg.wParam;
#else
  ExitProcess(msg.wParam);
#endif

par :
     return msg.wParam;


sinon, j'ai une erreur :
  [Linker error] undefined reference to `WinMain@16'
  ld returned 1 exit status

quelqu'un peut m'expliquer ?
merci

Commentaire de deck_bsd le 04/08/2006 17:02:51

sir vecchio est en grande forme ces temps si :D Bonne source :D (vivi je peut utiliser les ressources now mdr).

Commentaire de vecchio56 le 11/08/2006 22:34:45 administrateur CS

Oui pour le  RemoveFontMemResourceEx j'ai vu qu'on peut l'appeler aussitot, le HFONT n'en a pas besoin.
Pour l'option: si, elle diminue la taille de l'exécutable ici (103Ko au lieu de 134Ko avec WinMain)

Commentaire de BruNews le 11/08/2006 23:15:20 administrateur CS

C'est fou cette histoire, l'autre jour je me suis retrouvé avec un exe lié à msvcrt8.dll pour cause que l'exe appelait _memset et _memcpy sur cette dll. J'ai viré la dépendance en fournissant mes funcs au lieu des 2 originalez.
Faut dire que c'était la 1ere fois que je notais cela et l'exe de vecchio non plus n'a pas de dépendance.
Je note pourtant le
call _memset
dans l'asm produit par le compilo.
Mystique tout cela, sera à approfondir.

Commentaire de vecchio56 le 11/08/2006 23:17:30 administrateur CS

BruNews> Il en faudra des années avant de comprendre toutes ces options de VS2005. Tout était bien plus simple sous 2003, pas de mauvaises surprises

Commentaire de racpp le 11/08/2006 23:49:50 administrateur CS

vecchio56 >> Avec WNDCLASSEX wcex={0} la taille de l'exe est plus petite car memset() ajoute beaucoup plus d'octets. J'avais déja fait des tests. Je parle bien sûr d'un exe autonome sans aucune dépendance.
brunews >> C'est justement à cause de cette msvcrt80.dll que j'ai découvert tout cela. Cette dll n'est pas présente sur tous les ordinateurs et cela nous oblige à la lier statiquement dans le programme. Même en virant toute référence à la CRT, mes programmes en dépendent toujours à cause de certaines APIs. RegisterClassEx() n'est pas la seule car j'ai remarqué le même comportement avec d'autres. J'ai l'intention de les répertorier et essayer de faire un tutorial à ce sujet.

Commentaire de racpp le 12/08/2006 00:51:42 administrateur CS

Je viens de remarquer qu'on ne peut pas déscendre sous les 100ko car la ressource seule fait 97ko.

Commentaire de vecchio56 le 12/08/2006 11:41:53 administrateur CS

En fait le warning apparait quand on utiliser à la fois memset et RegsiterClassEx

RegisterClassEx -> pas de warning
memset et RegisterClassEx -> warning
memset et RegisterClass -> pas de warning

Je regarderait les sorties asm pour voir

Commentaire de vecchio56 le 12/08/2006 12:02:21 administrateur CS

A partir de 44 octets memset n'est plus inlinée en fait

Commentaire de racpp le 12/08/2006 16:47:39 administrateur CS

Bonjour,
Chez moi le warning apparait avec RegisterClassEx(), seule ou avec memset().
A propos de RegisterClassEx(), je suis tout à fait d'accord. Si elle appelle _memset(), ça doit être en dehors de notre prog.
Personnellement, quand je veux que mon exe soit le plus petit possibe, je mets le code en C, je mets l'option /NODEFAULTLIB pour le linker et /GS- pour le compilateur. Je fouris dans le code la fonction d'entrée WinMainCRTStartup(). Un jour, en étant sûr que mon code ne fait aucun appel à la CRT, je me retrouve devant des erreurs indiquant les fonctions de la CRT manquantes. J'ai alors mis en commentaire tout le code sauf la WinMain(). Et là je découvre qu'avec RegisterClassEx() le linker demande _memset(). En la remplaçant par RegisterClass(), l'erreur diparait et l'exe est généré.
Dans le post suivant, je mettrai un petit exemple de code à tester.

Commentaire de racpp le 12/08/2006 17:01:35 administrateur CS

#include <windows.h>

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmd,int show)

{
    WNDCLASSEX wc={0};
    RegisterClassEx(&wc);
    return 0;
}


int WINAPI WinMainCRTStartup(void)
{
    int retour;
    retour = WinMain( GetModuleHandle(0),0,0,1 );  
    return retour;
}

Commentaire de racpp le 12/08/2006 17:23:23 administrateur CS

Conclusion:
- Pour les tailles inférieures ou égales à 40 octets -> ={0}
- Pour les autres, fournir une fonction perso.

Tu as testé mon petit code? Tu as vu les fonctions manquantes affichées en clair?

Commentaire de racpp le 12/08/2006 17:31:21 administrateur CS

Dans le cas de WNDCLASSEX on peut juste mettre les autres membres à 0 et virer memset(). Ca permet de gagner 3Ko. Sans la ressource, l'exe ne ferait pas plus de 3ko.
Pourquoi ne pas choisir une police d'une dizaine de Ko?

Commentaire de racpp le 12/08/2006 17:59:36 administrateur CS

Ce code est fait pour Visual C Express 2005. Ca doit être pareil avec la version complète car il utilise le même compilo et linker.
J'ai donné le code pour répondre à ta question sur comment je sais que c'est que c'est _memset qui manque. Avec ce code, le linker affiche:
error LNK2001: unresolved external symbol _memset
Si ça t'interesse, je peux t'envoyer le petit projet complet. Avec cette méthode, on est sûr qu'aucune fonction de la CRT n'est ajouté à notre exe.
A propos des 100ko, puisque tu cherches à diminuer la taille de l'exe en mettant ton point d'entrée, pourquoi ne pas choisir une police plus petite et gagner encore des dizaines de ko?

Commentaire de racpp le 12/08/2006 18:43:43 administrateur CS

J'ai envoyé le projet.
Certes le fichier police est utile, mais un autre de moindre taille sera aussi utile puisque cette police ne sert qu'à démontrer le fonctionnement d'une fonction. Ce serait préférable de choisir un fichier plus petit. Ainsi on gagnera en taille de l'exécutable et en occupation mémoire. C'est mon point de vue.

Commentaire de racpp le 12/08/2006 20:07:35 administrateur CS

Brunews >> J'aimerais bien avoir ton avis aussi sur le petit projet que j'ai envoyé à vecchio56. C'est une méthode de contrôle total sur les dépendances. Le compilo ignore totalement la CRT et le linker affiche le nom de toute fonction tentant d'y accéder. Si ça t'intéresse, laisse une adresse émail par MP.

Commentaire de racpp le 12/08/2006 20:16:04 administrateur CS

Ok merci
Bon appétit

Commentaire de BruNews le 13/08/2006 00:40:44 administrateur CS

J'oubliais de préciser qu'ainsi on obtient un exe de 2 Ko.
Je remets le proj ici:
http://bnmvp.free.fr/nocrt.zip
ça permettra de vérifier les options de compilo et linker.

Commentaire de BruNews le 13/08/2006 14:44:24 administrateur CS

oups, c'est: if(--len) goto mem8SET;

Commentaire de BruNews le 13/08/2006 14:54:33 administrateur CS

moralité: pas de code après resto.

Commentaire de BruNews le 13/08/2006 19:03:21 administrateur CS

ça je l'ai déjà eu, si la signature complète de la fonction ressemble à une intégrée de la CRT, il met la sienne.
J'avais résolu en mettant du code asm en remplacement.

Commentaire de vecchio56 le 13/08/2006 19:52:29 administrateur CS

Autant les pb précédents sont plus ou moins expliqué, autant cette fois je comprends pas. Voici le code généré par ma fonction MemSet:

PUBLIC _MemSet
EXTRN _memset:PROC
; Function compile flags: /Ogtpy
; COMDAT _MemSet
_TEXT SEGMENT
_dst$ = 8 ; size = 4
_byte$ = 12 ; size = 4
_size$ = 16 ; size = 4
_MemSet PROC ; COMDAT

; 40   :   char* end = (char*)dst + size, *p;

mov ecx, DWORD PTR _dst$[esp-4]
mov eax, DWORD PTR _size$[esp-4]
add eax, ecx

; 41   :   for(p = (char*)dst; p != end; *p++ = byte);

cmp ecx, eax
je SHORT $LN3@MemSet
sub eax, ecx
mov DWORD PTR _size$[esp-4], eax
mov DWORD PTR _dst$[esp-4], ecx
jmp _memset
$LN3@MemSet:

; 42   : }

ret 0
_MemSet ENDP
_TEXT ENDS

Je ne pense pas que ce soit un pb de signature (même pb en inversant l'ordre des params)

Sinon t'aurais pas une bonne memset perso sous la main?

Commentaire de BruNews le 13/08/2006 20:00:10 administrateur CS

he he, tu as sentis venir ??? je démarrais justement une lib perso pour memset et memcpy, n'y aura plus qu'à mettre la lib dans dossier du proj et inclure son h.
Je vais faire 2 versions de chaque (enfin j'y réfléchis), aligné et non aligné.

Commentaire de racpp le 13/08/2006 20:39:52 administrateur CS

Voici la fonction que j'utilise:
void FillMem(void *destination, DWORD  longueur,BYTE octet)
{
// Obtenir un pointeur sur DWORD:
DWORD*  destination32=(DWORD*)destination;
// Calculer la taille en DWORDs:
DWORD taille32=longueur/4;
// Former un DWORD dont chaque octet contient la valeur de notre octet:
DWORD groupe=(octet*0x1000000 | octet*0x10000 | octet*0x100 | octet);
// Si la longueur est inférieure à 4 on met juste les octets qu'il faut:
switch (longueur-(taille32*2)) // astuce:
{
case 3: ((BYTE*)destination)[longueur-3] = octet;
case 2: ((BYTE*)destination)[longueur-2] = octet;
case 1: ((BYTE*)destination)[longueur-1] = octet;
}
// Remplir par notre DWORD tant que la taille est supérieure à 0:
while( taille32-- > 0 ) *(destination32++) = groupe;
}

Elle ne doit pas être aussi rapide que celle de Brunews, mais elle fonctionne très bien. Je la soumets à vos remarques.

Commentaire de BruNews le 13/08/2006 21:11:45 administrateur CS

C'est clair qu'il faut insérer 4 octets par passe.
Par contre faudra remplacer les multiplications, tu peux obtenir 'groupe' en 3 MOV.

Commentaire de BruNews le 13/08/2006 21:36:20 administrateur CS

décalages + 4 OR

Faisons que octet est dans AL et on met 'groupe' dans EAX:
mov ah, al
mov dx, ax
shl eax, 16
mov ax, dx
J'avais oublié un shl avec les 3 mov.

Comme d'hab, ne croyons rien et comparons, regarde ton listing asm et on sera certain de ce qui est préférable.

Commentaire de HeavenForsaker le 26/06/2007 12:14:14

Bon idem pour moi, le compilo remplace mes fonctions perso par de la CRT, les voici :

char *asmemset(void *dest, int c, unsigned int count)
{
register char *st = (char *)dest;

while (count-- > 0)
*st++ = c;

return (char *)dest;
}
//------------------------------------------------------------------------------

char *asmemcpy(void *dest, const void *src, unsigned int count)
{
register char *des = (char *)dest;
register const char *sr = (const char *)src;

while (count-- > 0)
*des++ = *sr++;

return (char *)dest;
}
//------------------------------------------------------------------------------

int asmemcmp(const void *buf1, const void *buf2, unsigned int count)
{
register const char *b1 = (const char *)buf1;
register const char *b2 = (const char *)buf2;

while (count-- > 0)
{
if (*b1++ != *b2++)
return b1[-1] < b2[-1] ? -1 : 1;
}

return 0;
}
//------------------------------------------------------------------------------

Est ce que par hasard vous auriez un set de fonction que le compilo ne detecte pas comme étant similaire a celle de la CRT ?
Tu disais BruNews que tes fonction asm n'était pas détectée ? pourrais tu publier tes fonctions ? j'ai juste besoin de ces 3 la , memcpy, memset et memcmp.

Commentaire de BruNews le 26/06/2007 17:21:44 administrateur CS

trop lent par octet.
Versions pour buffers alignés ou non. Utiliser les 'AL' quand tu es certain de l'alignement sur 4 de destination (souvent le cas dans code propre).

void __fastcall bnzeromemAL(void *pmem, DWORD len)
{
  BYTE *p = (BYTE*) pmem;
  DWORD r = len;
  if(!(len >>= 3)) goto prepm1SET;
mem8SET:
  *((DWORD*) p) = 0;
  *((DWORD*) (p + 4)) = 0;
  p += 8;
  if(--len) goto mem8SET;
prepm1SET:
  if(!(r &= 7)) goto zeromemEXIT;
mem1SET:
  *p++ = 0;
  if(--r) goto mem1SET;
zeromemEXIT: return;
}

void __fastcall bnzeromemUNAL(void *pmem, DWORD len)
{
  BYTE *p = (BYTE*) pmem;
  DWORD r;
  if(!len) goto zeromemEXIT;
  r = ((DWORD) p) & 3;
  if(!r) goto okALIGN;
  *p++ = 0;
  if(--len == 0) goto zeromemEXIT;
  if(--r == 0) goto okALIGN;
  *p++ = 0;
  if(--len == 0) goto zeromemEXIT;
  if(--r == 0) goto okALIGN;
  *p++ = 0;
  if(--len == 0) goto zeromemEXIT;
okALIGN:
  r = len;
  if(!(len >>= 3)) goto prepm1SET;
mem8SET:
  *((DWORD*) p) = 0;
  *((DWORD*) (p + 4)) = 0;
  p += 8;
  if(--len) goto mem8SET;
prepm1SET:
  if(!(r &= 7)) goto zeromemEXIT;
mem1SET:
  *p++ = 0;
  if(--r) goto mem1SET;
zeromemEXIT: return;
}

__declspec(naked) void __fastcall bnfillmemAL(void *pmem, BYTE v, DWORD len)
{ // ECX = pmem, EDX = v, [esp+4] = len
  __asm {
    mov     eax, ecx        ; EAX = pmem
    and     edx, 0FFh       ; octet seul
    mov     ecx, [esp+4]    ; ECX = len
    mov     [esp-8], esi
    mov     [esp-4], ebx
    mov     dh, dl
    test    ecx, ecx
    je      short fillEXIT
    mov     esi, ecx
    mov     ebx, edx
    shr     ecx, 3
    je      short prepf1SET
    shl     edx, 16
    mov     dx, bx
f8SET:
    mov     [eax], edx
    mov     [eax+4], edx
    add     eax, 8
    sub     ecx, 1
    jnz     short f8SET
prepf1SET:
    and     esi, 7
    je      short fillCLEAN
f1SET:
    mov     [eax], dl
    add     eax, 1
    sub     esi, 1
    jnz     short f1SET
fillCLEAN:
    mov     ebx, [esp-4]
    mov     esi, [esp-8]
fillEXIT:
    ret   4
  }
}

__declspec(naked) void __fastcall bnfillmemUNAL(void *pmem, BYTE v, DWORD len)
{ // ECX = pmem, EDX = v, [esp+4] = len
  __asm {
    mov     eax, ecx        ; EAX = pmem
    and     edx, 0FFh       ; octet seul
    mov     ecx, [esp+4]    ; ECX = len
    mov     [esp-8], esi
    mov     [esp-4], ebx
    mov     dh, dl
    test    ecx, ecx
    je      short fillEXIT
    mov     ebx, eax
    and     ebx, 3
    je      short okALIGN
    mov     [eax], dl
    add     eax, 1
    sub     ecx, 1
    jz      short fillCLEAN
    sub     ebx, 1
    jz      short okALIGN
    mov     [eax], dl
    add     eax, 1
    sub     ecx, 1
    jz      short fillCLEAN
    sub     ebx, 1
    jz      short okALIGN
    mov     [eax], dl
    add     eax, 1
    sub     ecx, 1
    jz      short fillCLEAN
okALIGN:
    mov     esi, ecx
    mov     ebx, edx
    shr     ecx, 3
    je      short prepf1SET
    shl     edx, 16
    mov     dx, bx
f8SET:
    mov     [eax], edx
    mov     [eax+4], edx
    add     eax, 8
    sub     ecx, 1
    jnz     short f8SET
prepf1SET:
    and     esi, 7
    je      short fillCLEAN
f1SET:
    mov     [eax], dl
    add     eax, 1
    sub     esi, 1
    jnz     short f1SET
fillCLEAN:
    mov     ebx, [esp-4]
    mov     esi, [esp-8]
fillEXIT:
    ret   4
  }
}

Commentaire de HeavenForsaker le 26/06/2007 22:45:00

Cool merci BruNews ! j'ai plus le vilain message CRT :-)

J'avais un autre message quand j'avais mis "Ignore All Default Libraries" à yes :
error LNK2001: unresolved external symbol __chkstk

Pour ceux qui l'ont eu c'est à cause d'un buffer trop gros, j'en avait un a 768 WCHAR je l'ai descendu a 256 et plus de message même avec cette option activée.