flat assembler
Message board for the users of flat assembler.
 Home   FAQ   Search   Register 
 Profile   Log in to check your private messages   Log in 
flat assembler > Macroinstructions > fasmg freezes on listing macro (split-off thread)

Goto page 1, 2  Next
Author
Thread Post new topic Reply to topic
jmg



Joined: 18 Sep 2016
Posts: 62
Just had fasmg freeze/never exit....

Turns out this typo gives no errors, and simply never exits.
I'd usually expect ORG 0 to be a default, and maybe an overlap error result, but not a no-message-lock-up ?


dd 20_000_000/4 ; fasmg never exits with typo of data before ORG
ORG 0


This is fine :

ORG 0
dd 20_000_000/4 ; waitx param
Post 14 Oct 2016, 03:29
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland

jmg wrote:
I think here you talk about some internal operations ?

No, I meant to try to arrange the listing macro differently and see if it makes it a bit faster.


jmg wrote:
Just had fasmg freeze/never exit....

Turns out this typo gives no errors, and simply never exits.
I'd usually expect ORG 0 to be a default, and maybe an overlap error result, but not a no-message-lock-up ?


dd 20_000_000/4 ; fasmg never exits with typo of data before ORG
ORG 0


This is fine :

ORG 0
dd 20_000_000/4 ; waitx param

Is this the complete source that causes the problem? If not, please provide the complete minimum source text that I can use to reproduce this (the above one works fine for me). What is your environment? And the exact fasmg version?
Post 14 Oct 2016, 05:57
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62
This code fails..



Code:

; P8X32_PropMacros.asm

; include 'hex.inc'     ; comment to create Binary image - change MAKE.CMD if inactive.
include 'listing.inc'  ; Include this to enable .LST generate
  dd  20_000_000/4  ; waitx param

ORG 0
  dd  20_000_000/4  ; waitx param
  dd  20_000_000





but checking I see it does seem to need that listing.inc in order to fail - from another post

Code:

define Listing 

namespace Listing 
        base = $$ 
        offset = $ 
        macro disphex number*,digits:8 
                repeat digits 
                        digit = ((numbershr ((%%-%shl 2)) and 0Fh 
                        if digit < 10 
                                display '0'+digit 
                        else 
                                display 'A'+digit-10 
                        end if 
                end repeat 
        end macro 
end namespace 

macro ? line
        line 
        namespace Listing 
                if ~ $$ eq base 
                        base = $$ 
                        offset = $$ 
                end if 
                bytes = $ - offset 
                if $ - bytes < $$ 
                        bytes = $ - $$ 
                end if 
                offset = $ 
                disphex (offset scale 0)-bytes,8 
                display ': ' 
                column = 0 
                while bytes 
                        if column = 8 
                                column = 0 
                                display 13,10,'          ' 
                        end if 
                        load data:byte from $ - bytes 
                        disphex data,2 
                        display ' ' 
                        bytes = bytes - 1 
                        column = column + 1 
                end while 
                repeat 8-column 
                        display '   ' 
                end repeat 
                display `line,13,10 
        end namespace 
end macro


Post 14 Oct 2016, 08:55
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland
I see, you still use the old, buggy version of that macro. I corrected it later. The problem lies here:

Code:
                while bytes
                        ; ...
                        bytes = bytes - 1
                end while

It may happen that "bytes" is negative - this is what happens when you do "ORG 0" when you are already at address 4, the difference that lands in the "bytes" variable is then negative 4.

Since "while bytes" is equivalent to "while bytes <> 0", when initial value is negative you get infinite loop.

The correction that I included in the other thread was simply to change it to:

Code:
                while bytes > 0

Post 14 Oct 2016, 10:14
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:
I see, you still use the old, buggy version of that macro. I corrected it later.
The correction that I included in the other thread



thanks, I applied that, but now I notice this effect

change of just a single line to include older or newer listing.inc, yields

include 'listing_o2.inc' ; older gives 1 pass, 1.1 seconds, 16520 bytes.

include 'listing.inc' ; newer gives 2 pass, 2.4 seconds, 16520 bytes

Something in that fixed code, is forcing a second pass ?

Suggestion: I think you can still edit the first post,in that thread ?
It can be easier to find/follow, if the lastest version, with a version number, is included in the first post - ie the first post has the revisions, and readers do not need to trawl/merge to find latest.


Last edited by jmg on 17 Oct 2016, 01:44; edited 1 time in total
Post 17 Oct 2016, 00:50
View user's profile Send private message Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62
some more info, when I apply this, combined with the HEX.INC macros, these effects are seen

include 'hex.inc' ;
include 'listing.inc' ; latest, gives 2 passes, 27.4 seconds, 46482 bytes.

include 'hex.inc' ; older 1 pass, 9.6 seconds, 46482 bytes.
include 'listing.inc'

and the pairing somehow effects listing, and it bumps from 4162 lines to 7910 lines.
Bonus lines look to all be 18 spaces per line.

This source can give 1 pass, 1.1 seconds, 16520 bytes, without hex.inc and older listing version.
Post 17 Oct 2016, 01:17
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland
Are you using this listing combined with the faster disphex macro I suggested elsewhere? It was written in a hurry and I had a small mistake there. This line:

Code:
load digit from HexDigits:((numbershr ((%%-%shl 2)) and 0Fh


should have been

Code:
load digit:byte from HexDigits:((numbershr ((%%-%shl 2)) and 0Fh

When there is no explicit size, fasmg uses the size associated with symbols used for addressing (unlike fasm, which assumed size 1), and this makes no sense in this case.
Post 17 Oct 2016, 07:49
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62
Thank's - I've updated my listing.

That still does not explain why the 'improved' listing code change bumps to 2 passes ? (which has a significant slow down effect).

Likewise, the hex.inc and Listing.inc seem to interact badly, and slow down more.

These speed-impacts are large - in all cases the file-info is the same, and the same code comes out the other end, just in Binary or hex and with/without listing.

No Listing, Binary out:
1 pass, 0.2 seconds, 16520 bytes.

Earlier 1 pass Listing
1 pass, 1.1 seconds, 16520 bytes.

add hex.inc
1 pass, 9.6 seconds, 46482 bytes.

Newer 'hex.inc' & 'listing.inc'
2 passes, 27.4 seconds, 46482 bytes.

but there are bugs in there, as the pairing somehow effects listing, and it bumps from 4162 lines to 7910 lines. Bonus lines look to all be 18 spaces per line.

Those speed impacts look to make a good case for having HEX & LST as a native options in fasmg, as they are pretty fundamental assembler leg-work.
Post 17 Oct 2016, 20:51
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland

jmg wrote:
but there are bugs in there, as the pairing somehow effects listing, and it bumps from 4162 lines to 7910 lines. Bonus lines look to all be 18 spaces per line.

I would need to see the exact versions of these macros that you use, the best would be the complete set of files to reproduce the problem. I've been putting many different versions of these macros on the board, sometimes with bugs - and, frankly, I thought that I'm just giving some simple examples to demonstrate some general methods that others might refine into something suitable for their needs. None of them were the "perfect" version, I even noted in several threads already that creation of a good macro framework for given architecture requires careful design of the interactions between various parts, and any macros should be adapted accordingly.


jmg wrote:
Those speed impacts look to make a good case for having HEX & LST as a native options in fasmg, as they are pretty fundamental assembler leg-work.

The main principle of fasmg is that it is a pure macro engine. It could become a base for fasm 2 or other similar assemblers, and such fasm 2 would implement some output formats internally (just like fasm 1), but fasmg intentionally does not. In fasmg macros need to have control over everything - but as soon as the assembler starts to implement some things (like output formats with relocations) internally, it becomes harder and harder to let the macros control all aspects of the assembly (for example, up to this day I did not manage to create a satisfactory mechanism of allowing macros to generate custom relocation formats in fasm). Therefore I decided to go in this direction - considering that nowadays computers are so fast that even the insanely complex macros like x64 output with relocations can still assemble some programs in reasonable time on my Windows tablet (the self-assembly of fasmg as either PE or a relocatable ELF object takes 7-8 seconds here, this is in fact similar time to how long the self-assembly of fasmw originally lasted on my good old Pentium 60 MHz). It is an experiment that turned out very interesting, and I found out that there are some people that find it useful enough (obviously it works best for the ones that are already familiar with fasm, since fasmg takes many features of fasm's macros and improves them), so I decided to work on it a bit more. But still, fasm 2 and perhaps other natively-implemented assemblers based on this engine may be created in the future. I planned to create some kind of assembler construction kit based on fasmg's engine - but for now experiments with macros eat all my free time. Having x86/x64 macros I can experiment with how things could work in fasm 2, without having the actual fasm 2 - this is a very fruitful environment for me.
Post 17 Oct 2016, 21:30
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:
I would need to see the exact versions of these macros that you use, the best would be the complete set of files to reproduce the problem.



I'll try to attach:


Description:
Download
Filename: hex.inc
Filesize: 1.23 KB
Downloaded: 30 Time(s)

Description:
Download
Filename: listing.inc
Filesize: 2.42 KB
Downloaded: 28 Time(s)

Description:
Download
Filename: P8X32_PropMacros.asm
Filesize: 20.82 KB
Downloaded: 28 Time(s)

Post 17 Oct 2016, 22:18
View user's profile Send private message Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:


jmg wrote:
Those speed impacts look to make a good case for having HEX & LST as a native options in fasmg, as they are pretty fundamental assembler leg-work.

The main principle of fasmg is that it is a pure macro engine. It could become a base for fasm 2 or other similar assemblers, and such fasm 2 would implement some output formats internally (just like fasm 1), but fasmg intentionally does not. In fasmg macros need to have control over everything - but as soon as the assembler starts to implement some things (like output formats with relocations) internally, it becomes harder and harder to let the macros control all aspects of the assembly (for example, up to this day I did not manage to create a satisfactory mechanism of allowing macros to generate custom relocation formats in fasm). Therefore I decided to go in this direction - considering that nowadays computers are so fast that even the insanely complex macros like x64 output with relocations can still assemble some programs in reasonable time on my Windows tablet (the self-assembly of fasmg as either PE or a relocatable ELF object takes 7-8 seconds here, this is in fact similar time to how long the self-assembly of fasmw originally lasted on my good old Pentium 60 MHz). It is an experiment that turned out very interesting, and I found out that there are some people that find it useful enough (obviously it works best for the ones that are already familiar with fasm, since fasmg takes many features of fasm's macros and improves them), so I decided to work on it a bit more. But still, fasm 2 and perhaps other natively-implemented assemblers based on this engine may be created in the future. I planned to create some kind of assembler construction kit based on fasmg's engine - but for now experiments with macros eat all my free time. Having x86/x64 macros I can experiment with how things could work in fasm 2, without having the actual fasm 2 - this is a very fruitful environment for me.



I can understand that, but native support does not have to exclude macros & their flexible use.
Macro's have pluses, but for these most basic of tasks, 'flexible' matters less than speed, and those speed impacts are significant. 0.2s to 27s is a massive hit !

Intel hex especially, is very well defined, and is simply an output format-variant.
Even a LST file is not widely variable, they all follow the same rules.
Address: Hex Info : Source line fragment.

Given the interaction of macros here, maybe it is better to just include a BIN2HEX separate pgm with fasmg, that can work on the BIN output.

A good (but old) example is here, has most of the options users need...

http://www.keil.com/download/docs/113.asp

I'd also like to see a dbhex choice, aka ASCII hex, but as ASM INCLUDE format
as
ORG OptionalOffsetValue
DB 0x01,0x02, etc

also has mention of srec_cat, and download of this
https://sourceforge.net/projects/srecord/files/srecord-win32/
then run as
srec_cat P8X32_PropMacros.bin -binary -o P8X32_PropMacros.hex -intel
seems very fast.

and it even has the DB output too... Smile

srec_cat P8X32_PropMacros.bin -binary -o P8X32_PropMacros.DB -ASM

Looks like a better HEX solution all round, and that leaves Listings...

Addit: Strange, I was unable to get any of the documented -ASM options to stick, and even srec_cat -Help fails too ? Lucky for me, the defaults are tolerable.


Last edited by jmg on 18 Oct 2016, 00:27; edited 1 time in total
Post 17 Oct 2016, 23:18
View user's profile Send private message Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:
...the self-assembly of fasmg as either PE or a relocatable ELF object takes 7-8 seconds here, this is in fact similar time to how long the self-assembly of fasmw originally lasted on my good old Pentium 60 MHz)...


Now that's cool & would make a good demonstration.
Suggestion:
Can you include a directory in the install, that can do that self-assembly of fasmg ?

addit: this seems to work ? Is it really this simple ?

..\fasmg windows/fasmg.asm fasmg.exe

Reports:
flat assembler g version 0.99.1476366664
4 passes, 14.5 seconds, 50176 bytes.
Post 17 Oct 2016, 23:33
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland

jmg wrote:
I can understand that, but native support does not have to exclude macros & their flexible use.

Yes, and an assembler like fasm 2 would still have the complete macro engine of fasmg beside the natively implemented formatters and instruction encoders. But then the macros would no longer be able to control everything like they can when everything is macro-based, like in fasmg. I know that the idea behind fasmg is a bit insane, but it is just a culmination of what I've been doing for years with fasm and I find it very inspiring.

Thus what you are looking for is perhaps a specialized assembler based on this engine, like the nonexistent fasm 2. I'm going to work on my fasmg-based "assembler construction kit" for this purpose, but it would still require some able and interested people that could use such kit to make actual assemblers, and this would probably be a bit harder for a third person compared to writing macro packages for fasmg (though when one is accustomed to x86 assembly, then not that much harder, the internal interfaces of fasmg engine are relatively simple to use).


jmg wrote:
Can you include a directory in the install, that can do that self-assembly of fasmg ?

addit: this seems to work ? Is it really this simple ?

..\fasmg windows/fasmg.asm fasmg.exe

Yes, it works just like that. The docs/fasmg.txt mentions it too. The sources are prepared in such way that either fasm or fasmg can be used to assemble them.
Post 18 Oct 2016, 09:21
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:
... I know that the idea behind fasmg is a bit insane, but it is just a culmination of what I've been doing for years with fasm and I find it very inspiring..


It might not be main-stream, but fasmg is more 'great' than 'a bit insane' Smile
Post 18 Oct 2016, 09:51
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland

jmg wrote:
I'll try to attach:

I have found out what causes the excess passes - the MATCH directive used by this variant to detect LIST/NOLIST switches forward-referenced the symbolic constants present in your macros. The easiest correction is to replace MATCH with RMATCH:

Code:
Listing? = 1  

namespace Listing
        base = $$  
        offset = $ 
        virtual at 0 
                HexDigits:: db '0123456789ABCDEF' 
        end virtual 
        macro disphex number*,digits:8 
                repeat digits  
                        load digit:byte from HexDigits:((numbershr ((%%-%shl 2)) and 0Fh
                        display digit 
                end repeat 
        end macro  
end namespace

macro nolist?
end macro

macro list?
end macro

macro ? line&  
        line
        rmatch =nolist?line
                Listing? =: 0
        else rmatch =list?line
                restore Listing?
        else
                if Listing
                        namespace Listing  
                                if ~ $$ eq base  
                                        base = $$  
                                        offset = $$  
                                end if  
                                bytes = $ - offset  
                                if $ - bytes < $$  
                                        bytes = $ - $$  
                                end if  
                                offset = $  
                                disphex (offset scale 0)-bytes,8  
                                display ': '  
                                column = 0  
                                while bytes > 0  
                                        if column = 8  
                                                column = 0  
                                                display 13,10,'          '  
                                        end if  
                                        load data:byte from $ - bytes  
                                        disphex data,2  
                                        display ' '  
                                        bytes = bytes - 1  
                                        column = column + 1  
                                end while  
                                repeat 8-column  
                                        display '   '  
                                end repeat  
                                display `line,13,10  
                        end namespace  
                end if
        end rmatch
end macro

This may the first time I used RMATCH to solve some problem. I implemented this directive because I predicted that it could sometimes be necessary, but until now I did not encounter a problem for which the use of RMATCH would be the correct solution - I need to remember this case, and perhaps make such example in documentation.
Post 18 Oct 2016, 10:03
View user's profile Send private message Visit poster's website Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland
Oh, and by the way: you can also use that NOLIST switch to disable listing before the HEX macros start to generate their data:

Code:
include 'hex.inc'
include 'listing.inc'
; postponed blocks are executed in reverse order, so this should get executed before HEX writer:
postpone
        nolist
end postpone

You even simply add this POSTPONE block to the LISTING.INC.
Post 18 Oct 2016, 10:08
View user's profile Send private message Visit poster's website Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland
I have noticed that the listing macro can also be made a bit faster by unrolling some loops and reading data in larger portions:

Code:
Listing? = 1

namespace Listing  
        base = $$  
        offset = $
        virtual at 0
                HexDigits:: db '0123456789ABCDEF'
        end virtual
end namespace

macro ? line&
        line
        rmatch =nolist?line
                Listing? =: 0
        else rmatch =list?line
                restore Listing?
        else
                if Listing
                        namespace Listing  
                                if ~ $$ eq base  
                                        base = $$  
                                        offset = $$  
                                end if  
                                bytes = $ - offset  
                                if $ - bytes < $$  
                                        bytes = $ - $$  
                                end if  
                                offset = $
                                address = (offset scale 0)-bytes
                                repeat 8
                                        load digit:byte from HexDigits:((addressshr ((%%-%shl 2)) and 0Fh
                                        display digit
                                end repeat
                                display ': '
                                if bytes < 0
                                        bytes = 0
                                end if
                                while bytes > 0
                                        if bytes > 8
                                                load data:8 from $ - bytes
                                                repeat 8
                                                        load digit:byte from HexDigits:(data shr ((%-1shl 3 + 4)) and 0Fh
                                                        display digit
                                                        load digit:byte from HexDigits:(data shr ((%-1shl 3)) and 0Fh
                                                        display digit,' '
                                                end repeat
                                                bytes = bytes - 8
                                                display 13,10,'          '
                                        else
                                                load data:bytes from $ - bytes
                                                repeat bytes
                                                        load digit:byte from HexDigits:(data shr ((%-1shl 3 + 4)) and 0Fh
                                                        display digit
                                                        load digit:byte from HexDigits:(data shr ((%-1shl 3)) and 0Fh
                                                        display digit,' '
                                                end repeat
                                                break
                                        end if
                                end while
                                repeat 8-bytes
                                        display '   '
                                end repeat
                                display `line,13,10
                        end namespace  
                end if
        end rmatch
end macro

macro nolist?
end macro

macro list?
end macro

postpone
        nolist 
end postpone


Also the HEX macro can be sped up a tiny little bit, by using the same look-up table trick:

Code:
virtual at 0
        HEX.digits:: db '0123456789ABCDEF'
end virtual

macro HEX.byte value
        HEX.checksum = (HEX.checksum + (value)) and 0FFh
        local digit
        load digit:byte from HEX.digits:(valueshr 4
        db digit
        load digit:byte from HEX.digits:(valueand 0Fh
        db digit
end macro

I'm going to include this improved version of HEX.INC in the official package.


Last edited by Tomasz Grysztar on 18 Oct 2016, 20:45; edited 1 time in total
Post 18 Oct 2016, 13:03
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62
Thanks, wow, that's a large improvement. Faster, and interactions gone.

It now gives

; Improved 19th oct hex and listing now gives
; 1 pass, 0.8 seconds, 16520 bytes. Listing only
; 1 pass, 1.3 seconds, 46482 bytes. Listing & Hex

Request: when publishing, can you include a heading something like

; Listing.inc macro, version 1.2.1510 https://board.flatassembler.net/topic.php?p=191113#191113
; Purpose: Create a listing output on Display of Adr: Hex Hex ... Source Line Portion

&
; hex.inc Macro, version 1.2.1510 https://board.flatassembler.net/topic.php?p=191113#191113
; Purpose : output file changes to intel hex format, instead of default Binary.


ie shows name, version number, and a link where any updates can be found.
Those updates should be refreshed in the first post of that link.
Post 18 Oct 2016, 19:50
View user's profile Send private message Reply with quote
Tomasz Grysztar
Assembly Artist


Joined: 16 Jun 2003
Posts: 6357
Location: Kraków, Poland
I have updated my above post just before you answered, with some additional corrections - lines without data were not indented properly.

The improved HEX macro is now in the official package. For the new listing macro I have not yet decided where to publish it.
Post 18 Oct 2016, 19:54
View user's profile Send private message Visit poster's website Reply with quote
jmg



Joined: 18 Sep 2016
Posts: 62

Tomasz Grysztar wrote:
I have noticed that the listing macro can also be made a bit faster by unrolling some loops and reading data in larger portions:



There is I think a small formatting bug in listing :


Code:

00000000define WC2 SUFF 10b
00000000define WZ2 SUFF 01b
00000000ORG 0
00000000FB F7 23 F6             NOT DIRB
00000004lp:
00000004FD FB 23 F6             NOT _OUTB
0000000825 26 80 FF 28 80 66 FD 
          WAITX #20_000_000/4
00000010F0 FF 9F FD             jmp lp
00000014R5 EQU 5
0000001428 FC 67 FD             WAITX #510
0000001828 0A 60 FD             WAITX R5
0000001C28 46 66 FD             WAITX #$123
0000002028 46 62 FD             WAITX $123
0000002444 33 22 11             dd 0x11223344
00000038FirstEQU EQU 0x55
0000003855                      DB FirstEQU
0000003953 69 6D 70 6C 65 20 53 
          74 72 69 6E 67          DB 'Simple String'
0000004621                      DB 33
00000047DB 0F 49 40             DD 3.141592653589793238462643
0000004B18 2D 44 54 FB 21 09 40 
          DQ 3.141592653589793238462643
000000530B                      DB 11
00000054ccDef EQU 1111b shl 18



Note DQ and other 8-byte lines, do not column-align, but bump to next line.

Also, source equates,defines etc I think should all be source-column placed, so the ideal .LST is formatted like this :


Code:

00000000:                         define WC2 SUFF 10b
00000000:                         define WZ2 SUFF 01b
00000000:                         ORG 0
00000000FB F7 23 F6             NOT DIRB
00000004:                         lp:
00000004FD FB 23 F6             NOT _OUTB
0000000825 26 80 FF 28 80 66 FD WAITX #20_000_000/4
00000010F0 FF 9F FD             jmp lp
00000014:                         R5 EQU 5
0000001428 FC 67 FD             WAITX #510
0000001828 0A 60 FD             WAITX R5
0000001C28 46 66 FD             WAITX #$123
0000002028 46 62 FD             WAITX $123
0000002444 33 22 11             dd 0x11223344
00000038:                         FirstEQU EQU 0x55
0000003855                      DB FirstEQU
0000003953 69 6D 70 6C 65 20 53 
          74 72 69 6E 67          DB 'Simple String'
0000004621                      DB 33
00000047DB 0F 49 40             DD 3.141592653589793238462643
0000004B18 2D 44 54 FB 21 09 40 DQ 3.141592653589793238462643
000000530B                      DB 11
00000054:                         ccDef EQU 1111b shl 18



All source lines are now column justified, and a column-copy in editor, will 'get-back' the source. This also allows LST parsing in the HEX Data columns, as source is never present there.
Post 18 Oct 2016, 20:16
View user's profile Send private message Reply with quote
Display posts from previous:
Post new topic Reply to topic

Jump to:  
Goto page 1, 2  Next

< Last Thread | Next Thread >

Forum Rules:
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum


Powered by phpBB © 2001-2005 phpBB Group.

Main index   Download   Documentation   Examples   Message board
Copyright © 2004-2016, Tomasz Grysztar.