LINUX.ORG.RU

Оффтоп про DLL

 , ,


0

1

понимаю, что вопрос к линукс не имеет отношения, но очень надо..:-) И так уже обматерился от визуальной студии

есть оффтоп, в нём есть (видимо нативная, не С#)DLL, так вот вопрос как её заюзать из С, желательно из mingw но не суть..

эта DLL-ка подключается к С# вот подобным макаром:

....
        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate Int32 DGetCommand(int Account);

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        public delegate Int32 DGetCommandSystemID(Int32 Account);
....
            hModule = NativeMethods.LoadLibrary(@"DllName.dll");
            GetCommand = NativeMethods.GetProcDelegate<DGetCommand>(hModule, "GetCommand");
            GetCommandSystemID = NativeMethods.GetProcDelegate<DGetCommandSystemID>(hModule, "GetCommandSystemID");
....

Совершенно не знаю С#, в виндовых DLL не разбираюсь, а вот понадобилось на старости лет :-)

PS. будете посылать на винфак - шлите сразу к конкретной инструкции :-)

Ответ на: комментарий от PPP328

нативная - написанная на с/c++ с сишными вызовами, про системность ничего не сказано.

anonymous ()
Ответ на: комментарий от PPP328

Берешь просто хидер, раз уж библиотека виндовая нативная системная.

вот как раз хидера (*.h, как впрочем и *.lib) нету, есть исключительно dll и демка к ней на C#..

по шагам, шарповое словоблудие выливается примерно в такой хидер:

extern "C" {

int32_t __stdcall DGetCommand(int Account); // или GetCommand ??

}
после чего линковщику указываю DLL-ку и должно «стрельнуть» ?

MKuznetsov ★★★★★ ()

видимо нативная

Открой в ilspy и увидишь. Ещё monodevelop умеет открывать бинари .net

Для использования из c просто объявляешь extern с сигнатурой, и всё.

anonymous ()

Сам пишешь хидер, и через LoadLibrary+GetProcAddress дергаешь. Сигнатуры функций очевидны помоему.

int __stdcall GetCommand(int account);
int __stdcall GetCommandSystemID(int account);

Можно заморочиться и .lib/.dll.a сделать средствами того же MinGW

lovesan ★★ ()

Тебе нужен ее хидер, где все прописано. Подключаешь его, кладешь ее так, чтоб к ней был доступ из твоего приложения (либо рядом с ехе, либо в системную папку), пишешь код, обращаясь к функциям в ней. Все.

Zhbert ★★★★★ ()
Ответ на: комментарий от lovesan

fasm

примеры на fasm отсюда про dll

fasmlib — кроссплатформенная библиотека (windows/linux) под fasm

например, HLA (транслируемый в fasm) : hlaexamples/Win32/icz /tut17.hla :

//Iczelion's tutorial #17: Dynamic Link Library (1)
program callDLL;

static
	TestFunction: procedure; external( "__imp_TestFunction" );

begin callDLL;
	TestFunction();
end callDLL;

сам hla умеет разные calling convention «из коробки» (fasm, впрочем, тоже)

пример на asmc, см. также Doszip Commander (sf.net) — ассемблер, форк jwasm + masm syntax в котором можно писать си-подобное такое вот (функции как в сишном синтаксисе. далее, см. doszip commander + его стд. библиотеку как аналог libc минималистичного — кроссплатформной стд библиотеки типа fasmlib)

MasmBasic, мануал и батарейки — бейсик, реализованный макросами Masm, то есть, по сути, ассемблер. имеет смысл использовать вместе с asmc или SolASM (зело быстрый ассемблер)

ещё также см. PureBasic, FastBasic и т.п. (транслируемые в fasm)

anonymous ()
Ответ на: fasm от anonymous

Re: fasm

1. на ассемблере писать довольно просто вызовы WinAPI либо libc (stdcall) либо даже кроссплатформенную библиотеку типа fasmlib, asmc doszip commander

2. можно взять простой язык, транслируемый в ассемблер: какой-то бейсик типа PureBasic или MasmBasic

3. или не такой уж простой, наподобие HLA (см. hla v2 как современное, но 32-битное; или сразу HLA v3 с зачатками поддержки 64-битности) — там есть высокоуровневый псевдокод, макросы, разные call conv, богатая стд. библиотека типа STL (HLA STD LIB)

выглядит паскалеподобное, даже есть ООП. но это всё-таки ассемблер: напрямую фигачим инструкциями типа

procedure WndProc( lParam:dword; wParam:dword; uMsg:uns32; hWnd:dword );
	@nodisplay;
	
begin WndProc;

	if( uMsg = w.WM_CREATE ) then
	
		w.CreateWindowEx
		(
			NULL,
			EditClass,
			NULL,
			w.WS_VISIBLE | w.WS_CHILD | w.ES_LEFT | w.ES_MULTILINE | 
				w.ES_AUTOHSCROLL | w.ES_AUTOVSCROLL,
			0,
			0,
			0,
			0,
			hWnd,
			EditID,
			hInstance,
			NULL
		);
		mov( eax, hwndEdit );
		w.SetFocus( eax );
		mov( @size( ofn ), ofn.lStructSize );
		mov( hWnd, ofn.hWndOwner );
		mov( hInstance, ofn.hInstance );
		mov( &FilterString, ofn.lpstrFilter );
		mov( &buffer, ofn.lpstrFile );
		mov( MAXSIZE, ofn.nMaxFile );
		
	elseif( uMsg = w.WM_SIZE ) then
	
		mov( lParam, eax );
		mov ( eax, edx );
		shr( 16, edx );
		and( $FFFF, eax );
		w.MoveWindow( hwndEdit, 0, 0, eax, edx, true );
		
	

//....		

	elseif( uMsg = w.WM_DESTROY ) then
	
		w.PostQuitMessage( 0 );
		
	elseif( uMsg = w.WM_COMMAND ) then
		
		mov( wParam, eax );
		if( lParam = 0 ) then
		
			if( ax = IDM_OPEN ) then
			
				mov
				(
						w.OFN_FILEMUSTEXIST
					|	w.OFN_PATHMUSTEXIST
					|	w.OFN_LONGNAMES
					|	w.OFN_EXPLORER
					|	w.OFN_HIDEREADONLY,
					ofn.Flags
				);
				w.GetOpenFileName( ofn );
				if( eax ) then
				
					w.CreateFile
					(
						&buffer,
						w.GENERIC_READ | w.GENERIC_WRITE,
						w.FILE_SHARE_READ | w.FILE_SHARE_WRITE,
						NULL,
						w.OPEN_EXISTING,
						w.FILE_ATTRIBUTE_ARCHIVE,
						NULL
					);
					mov( eax, hFile );
					w.GlobalAlloc
					( 
						w.GMEM_MOVEABLE | w.GMEM_ZEROINIT, 
						MEMSIZE 
					);
					mov( eax, hMemory );
					w.GlobalLock( eax );
					mov( eax, pMemory );
					w.ReadFile
					( 
						hFile, 
						val pMemory, 
						MEMSIZE-1, 
						SizeReadWrite, 
						NULL 
					); 
					w.SendMessage( hwndEdit, w.WM_SETTEXT, NULL, pMemory );
					w.CloseHandle( hFile );
					w.GlobalUnlock( pMemory );
					w.GlobalFree( hMemory );
						
				endif;
				w.SetFocus( hwndEdit );
				
			elseif( ax = IDM_SAVE ) then
			
				mov
				( 
					w.OFN_LONGNAMES | w.OFN_EXPLORER | w.OFN_HIDEREADONLY,
					ofn.Flags
				); 
				w.GetSaveFileName( ofn );
				if( eax ) then
				
					w.CreateFile
					( 
						&buffer,
						w.GENERIC_READ | w.GENERIC_WRITE,
						w.FILE_SHARE_READ | w.FILE_SHARE_WRITE,
						NULL,
						w.CREATE_NEW,
						w.FILE_ATTRIBUTE_ARCHIVE,
						NULL
					);
					mov( eax, hFile );
					w.GlobalAlloc
					(
						w.GMEM_MOVEABLE | w.GMEM_ZEROINIT,
						MEMSIZE
					);
					mov( eax, hMemory );
					w.GlobalLock( hMemory );
					mov( eax, pMemory );
					w.SendMessage
					( 
						hwndEdit, 
						w.WM_GETTEXT, 
						MEMSIZE-1, 
						pMemory 
					);
					w.WriteFile
					( 
						hFile, 
						val pMemory, 
						eax, 
						SizeReadWrite, 
						NULL 
					);
					w.CloseHandle( hFile );
					w.GlobalUnlock( pMemory );
					w.GlobalFree( hMemory );
					
				endif;
				w.SetFocus( hwndEdit );
				
			else
				w.DestroyWindow( hWnd );

			endif;
			
		endif;		
			
	else
	
		// If a WM_DESTROY message doesn't come along,
		// let the default window handler process the
		// message.  Whatever (non-zero) value this function
		// returns is the return result passed on to the
		// event loop.
		
		w.DefWindowProc( hWnd, uMsg, wParam, lParam );
		exit WndProc;
		
	endif;
	sub( eax, eax );
	
end WndProc;


anonymous ()
Ответ на: Re: fasm от anonymous

Re: fasm

то есть, этот код на HLA — высокоуровневый ассемблер (прозрачно транслируется в fasm/masm/gas, в HLA v3 есть напрямую генерация бинарников через HLA BE , без линкера)

есть стандартная библиотека, довольно высокоуровневая (шаблоны, ООП, GUI (HOWL) )

есть врапперы к батарейкам полуавтоматические

есть довольно высокоуровневый язык макросов (Compile Time Language, CTL) — символы символьной таблицы с типами и встроенными функциями, метаданными

в общем, на этом вполне можно себе лисп написать. будет дёшево и сердито, и довольно быстро (почти как SolASM по быстродействию — парсер в HLA v3 на memory mapped files + Btree)

и довольно расширяемо.

в общем, если взять какой-то простой лисп, да хотя бы picoLisp и переписать его на HLA — можно получить годное кроссплатформное приложение, и с батарейками «из коробки».

будет минималистичный (ассемблер же!!111) годный такой минилисп с батарейками.

кстати, можно PicoLisp портировать ещё быстрее: взять какой-нибудь fasmg (где разные ассемблеры реализованы разными наборами макросов, в разных namespaces) — и сделать fasmg макросами emit байткода picolisp-а.

anonymous ()
Ответ на: Re: fasm от anonymous

Re: fasm

Simple-C:

Simple C Compiler, Release 0.1.6

----------------------------------------------------------------

Simple C is a portable C compiler based on Small C/386. It is designed to run on Linux, but it should be usable on any Unix- like operating system for the x86 with minimal effort.

This compiler generates assembly code for NASM/FASM. It also requires the 'ld' tool from the GNU project (or an equivilent) to create runnable applications.

As Simple C is based on Small C, it is also public domain.

libc у него ну очень минималистичный.

anonymous ()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.