Macro display strings&
End Macro
    

The compilation time is still below 10 seconds, but I do not want it to crash, when I increase the input further.

So now I have to optimise my macros and I guess, loops would be a good starting point, but where should I have look at too? Are there any optimisation-tipps for fasmg you can give?

And how can I measure, which parts are really slow and should be optimised first? Or a feature-request: some macro, thats returns the current time in nanosecons, since compilation started. (Even if this probably will increase the compilation time, because more syscalls. And it could be quite tricky with multiple runs.)

flat assembler version g.hxhsr
3 passes, 1.0 seconds, 1922 bytes.

Macro display strings&
End Macro
    

flat assembler version g.hxhsr
3 passes, 9.1 seconds, 1922 bytes.

Macro display strings&
  Display strings
End Macro
    

flat assembler version g.hxhsr
3 passes, 9.7 seconds, 1922 bytes.

Repeat 100
  mov eax, ecx ;my definition of this x86-instruction
End Repeat
    

3 passes, 11.2 seconds, 2122 bytes.

Repeat 1000 ;factor 10, to I expect 110.0 seconds (about 2 minutes)
  mov eax, ecx ;my definition of this x86-instruction
End Repeat
    

3 passes, 264.4 seconds, 3922 bytes.

3 passes, 3.7 seconds, 3922 bytes.

I guess, redefining an internal macro is just a very bad idea?

repeat 1000000
        display ''
end repeat    

macro display? any&
end macro    

macro display? any&
        display any
end macro    

Repeat 2000000
  display `%
End Repeat
    

Macro display string&
End Macro
Repeat 2000000
  display `%
End Repeat
    

Macro display string&
  Display string
End Macro
Repeat 2000000
  display `%
End Repeat
    

myMemory allocate 12
myMemory reallocate 14
store byte 42 at myMemory: 13
load temp byte from myMemory: 13
    

virtual
  myMemory::
    rb 12
end virtual
myMemory = myMemory + 2
size = sizeof myMemory ;size = 14
store byte 42 at myMemory: 13
load temp byte from myMemory: 13
    

struc addToList entry*, value*, field
  repeat 1, item: entry
    match any, field
      .item#%#.#any = value
    else
      .item#% = value
    end match
  end repeat
end struc
struc getItem list*, entry*, field
  repeat 1, item: entry
    match any, field
      . = myList.item#%#.#any
    else
      . = myList.item#%
    end match
  end repeat
end struc
myList addToList 3, "foo"
myList addToList 3, "bar", bar
temp getItem myList, 3, bar
display temp
temp getItem myList, 3
display temp
    

myList[3] = "foo"
myList[3].bar = "bar"
display myList[3].bar, myList[3]
    

foo.bar = 0
foo.bar.a = 1
foo.bar.b = 2
foo.bar.a.b = 3
foo = 4
delete foo.bar.* ;to delete foo.bar.a, foo.bar.b and foo.bar.a.b, but not foo and foo.bar
    

I guess, the best way to speed up things is to reduce the number of passes and avoiding loops. I use in my macroinstructionset queques, stacks and other memory-structures, that do not necessarily get into the final output, but because these structures should be of dynamic size, I need at least 2 passes to calculate the required size.
One way to optimise this is to such memory-spaces, that can be accessed with load/store like data like (...)

But I really prefer something like this instead:

Code:

myList[3] = "foo"
myList[3].bar = "bar"
display myList[3].bar, myList[3]
    

myList#3 = "foo"
myList#3.bar = "bar"
display myList#3.bar, myList#3

myList.3 = "foo"
myList.3.bar = "bar"
display myList.3.bar, myList.3    

I can live without that, but this could decrease memory-usage.

Please take at look at the recent addition of VIRTUAL block continuation. This is more or less what you described here.

virtual as 'log'
  db 'this will be put in the separate file »outputfile.log«'
end virtual
    

virtual
  foobar::
end virtual
virtual foobar
  db "Hello World!", 13, 10
end virtual
    

I guess that the real issue you signal here is to have the ability to evaluate an expression to give an index within a single line. For that a macro is the only way.

myList#(expression)
    

And undefining all the symbols within a namespace is slow.

But the manual is a bit confusing, because it explains two separate things in one example

Tomasz Grysztar wrote:

I guess that the real issue you signal here is to have the ability to evaluate an expression to give an index within a single line. For that a macro is the only way.

Exactly. My idea was to implement a stack this way with an stack-pointer. I suggest to allow expressions like this

Code:

myList#(expression)
    

struc = expression&
  local temp, expr
  ;=! – my idea to reference the default =
  match list=[ list_expression =], .
    expr parseExpression expression
    temp parseExpression list_expression
    repeat 1, item: temp
      list.#% =! expr
    end repeat
  else
    temp checkSymbol .
    if ( temp = 0 )
       expr parseExpression expression
       . =! expr
    else
       compileExpression expression
       mov dword [ temp.addr ], eax
    end if
  end match
end struc
abc[1+2] = foo("bar", 3)