Hi everyone,

I am working on FASM IDE and I am thinking how to provide code re-use for a projects, which may be developed using IDE.

Currently, I know that FASM can 'include' the source into main ASM file and that would be enough to get some earlier coded component into the big project. That's one method of re-using code (or using a component).

However, there may be a case of a very large project, say thousands of included modules and I am worried that such large code will hit some limits of the FASM compiler.

Another way is that I can use DLLs as components - they export some functions and these functions can be called to re-use code inside a DLL. That is two methods already.

Now, my question: is it possible to use some other kind of binary components in FASM, like an OBJ file? I know FASM can produce COFF files, but can they be used to build other FASM applications or these COFF files used only to integrate with HLLs. Is there something in FASM which can provide the same feature as OBJ files in MASM? I need the ability to build a final EXE for a big project from binary non-DLL components. Is this possible?

.obj files are normally linked together using linker to form an executable (.exe or .dll under Windows).

Can .OBJ files be linked by FASM itself (without a linker)?

Nope

what is a linker?

are you talking about os-independent code?

It's a thing ignorance of which can make one e-proud.

So, the only two ways for components are: DLLs and "include 'source.asm'"? That's not much.

You can link several obj files to one executable using "linker".
FASM package does not contains linker, but you can use third party one.

I, personally don't like linkers and the one of the main reasons to use FASM is that it can generate executable files in several formats directly.
I believe, most of the FASM users like it because of this feature.

There are 3 main reasons for .obj files use:
1. To be able to link HLL and ASM modules - it serves mainly HLL - assembler does not need HLL modules, but HLL need assembly modules.

2. To allow using closed source modules, accessible only as a object files.

3. To provide faster compilation for slow assemblers and compilers that simply can't compile big sources fast enough.

All 3 reasons are void for FASM.

4. Code modularity without having to resort to dlls.

I don't like linkers either, but I would like some kind of (macro-)system that can merge several sources together in an easy way without having to chop up your modules into sections and including them in your main project.

Code modularity is completely achievable on source level. You can see FreshLib (and the whole Fresh project) for example how to make it.
If you don't want to deal with source repository, you can download the latest version of Fresh from download page. The package contains full source with many libraries on source level without any dll's or obj files.

That is what I do, basically.
I have Module.Inc (structures, constants and macros) and Module.Asm (plain code) for every module and then just include these as needed.