Is this question about how fasm/fasmg itself works or do you want to create windows-programmes with fasm/fasmg?

then better move the topic to ›compiler internals‹. Anyway, the core file is assembly.inc, best way is to start there, but I must confess, it is complicated, because Tomasz does not comment a lot.

There is a guide to fasm's internals, it also had some tiny updates later but I never finished it.

So there is no current overview about fasm itself and none for fasmg?

_shura wrote:

So there is no current overview about fasm itself and none for fasmg?

I never finished the aforementioned guide and all my design notes for fasm 1 were only on paper (I'd been showing my notepad to the audience of fasmcon 2006), though these were mainly layouts of data structures. Many of them have later become parts of FAS format specification and it is there where you can find the most up-to-date description of many of fasm's internal data formats.

As for the fasmg, all my design notes were digital since the beginning and you can find them in the Fossil repository. They focus more on the design of the language (note that they mostly predate an actual implementation) and have only little information on the internal data structures, but the fasmg sources themselves are more self-descriptive compared to fasm 1. At least fasmg sources use named structure fields and flags (in fasm 1 all of them were hard-coded numbers that I was looking up on my paper notes every time I worked with fasm's source).

Yeah, the good old magic numbers of fasm Anyway, it would be more helpful, if I know, what piece of code does what. E.g. where I have to start, if i want to add a feature to source-processing. I am currently program a compiler with fasmg-macros and I had the idea to replace the token-based system of fasmg with some kind of bytecode, that may speed up the compilation by fasmg.

macro foo bar
  if ( bar = 0 )
    ;some long code
  else if ( bar = 1 )
    ;also long code
  else
    ;even longer code
  end if
  ;always do this
end macro
    

_0:
  ;some long code
  done
_1:
  ;also long code
  done
_2:
  ;even longer code
  done
_3:
  push 0 ;argument 0
  pushArgument
  push 1
  compare
  push _1
  push _2
  branch
  done
_macro_foo:
  push 0 ;argument 0
  pushArgument
  push 0
  compare
  push _0
  push _3
  branch
  ;always do this
  done
    

depends on the design of the bytecode. But you said, that long macros are slow, because the assembler has to process e.g. the code in an if-statement, even if this path is not used in an specific macro-call. But with bytecode, you just can put the content of it in another memory and it does not get touched, if the statement is false:

macro foo bar 
  if ( bar = 0 ) 
    _1
  else if ( bar = 1 ) 
    _2
  else 
    _3
  end if     

But what about allowing some kind of preprocessed files with limited capabilities. The changes, that must be done in assembl_pass are obvious, I just have to add a check for a magic-number at the beginning of the includes source-file, but where can I add macros and strucs to the current/root namespace? this does not need access to other symbols than macros/strucs, because setting internal variables/flags of the included file can simply be done with macro-calls. So in the end, there are 3 different types of macros: internal macros like ›display‹ (fast), custom macros (slow) and preprocessed macros, that do not have the full capabilities, but are good enough for most purposes, like encoding x86-instructions.

Well, you just could explain more about the internals of fasmg, so I can try a first attempt.