mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-18 12:52:37 +03:00
780 lines
24 KiB
NASM
780 lines
24 KiB
NASM
; This program parses .fas file generated by fasm
|
|
; and prints the list of dependencies for make.
|
|
; Usage: fasmdep [-e] [<input file> [<output file>]].
|
|
; If input file is not given, the program reads from stdin.
|
|
; If output file is not given, the program writes to stdout.
|
|
; If the option -e is given, the program also creates an empty
|
|
; goal for every dependency, this prevents make errors when
|
|
; files are renamed.
|
|
|
|
; This definition controls the choice of platform-specific code.
|
|
;define OS WINDOWS
|
|
define OS LINUX
|
|
|
|
; Program header.
|
|
match =WINDOWS,OS { include 'windows_header.inc' }
|
|
match =LINUX,OS { include 'linux_header.inc' }
|
|
|
|
include 'fas.inc'
|
|
|
|
; Main code
|
|
start:
|
|
; 1. Setup stack frame, zero-initialize all local variables.
|
|
virtual at ebp - .localsize
|
|
.begin:
|
|
.flags dd ? ; 1 if '-e' is given
|
|
.in dd ? ; handle of input file
|
|
.out dd ? ; handle of output file
|
|
.buf dd ? ; pointer to data of .fas file
|
|
.allocated dd ? ; number of bytes allocated for .buf
|
|
.free dd ? ; number of bytes free in .buf
|
|
.outstart dd ? ; offset in .buf for start of data to output
|
|
.names dd ? ; offset in .buf for start of output names
|
|
.include dd ? ; offset in .buf to value of %INCLUDE%
|
|
.testname dd ? ; offset in .buf for start of current file name
|
|
.prevfile dd ? ; offset in .buf for previous included file name
|
|
.prevfilefrom dd ? ; offset in .buf for .asm/.inc for .prevfile
|
|
.localsize = $ - .begin
|
|
match =LINUX,OS {
|
|
.argc dd ?
|
|
.argv:
|
|
}
|
|
end virtual
|
|
|
|
mov ebp, esp
|
|
xor eax, eax
|
|
repeat .localsize / 4
|
|
push eax
|
|
end repeat
|
|
; 2. Call the parser of the command line.
|
|
call get_params
|
|
; 3. Load the input file.
|
|
; Note that stdin can be a pipe,
|
|
; useful in bash-construction "fasm input.asm -s >(fasmdep > input.Po)",
|
|
; so its size is not always known in the beginning.
|
|
; So, we must read input file in portions, reallocating memory if needed.
|
|
.readloop:
|
|
; 3a. If the size is less than 32768 bytes, reallocate buffer.
|
|
; Otherwise, goto 3c.
|
|
cmp [.free], 32768
|
|
jae .norealloc
|
|
; 3b. Reallocate buffer.
|
|
; Start with 65536 bytes and then double the size every time.
|
|
mov eax, 65536
|
|
mov ecx, [.allocated]
|
|
add ecx, ecx
|
|
jz @f
|
|
mov eax, ecx
|
|
@@:
|
|
call realloc
|
|
.norealloc:
|
|
; 3c. Read the next portion.
|
|
call read
|
|
sub [.free], eax
|
|
test eax, eax
|
|
jnz .readloop
|
|
; 4. Sanity checks.
|
|
; We don't use .section_* and .symref_*, so allow them to be absent.
|
|
mov edi, [.allocated]
|
|
sub edi, [.free]
|
|
; Note that edi = number of bytes which were read
|
|
; and simultaneously pointer to free space in the buffer relative to [.buf].
|
|
cmp edi, fas_header.section_offs
|
|
jb badfile
|
|
mov ebx, [.buf]
|
|
cmp [ebx+fas_header.signature], FAS_SIGNATURE
|
|
jnz badfile
|
|
cmp [ebx+fas_header.headersize], fas_header.section_offs
|
|
jb badfile
|
|
; 5. Get %INCLUDE% environment variable, it will be useful.
|
|
mov [.include], edi
|
|
mov esi, include_variable
|
|
sub esi, ebx
|
|
call get_environment_variable
|
|
; 6. Start writing dependencies: copy output and input files.
|
|
mov [.outstart], edi
|
|
; 6a. Copy output name.
|
|
mov esi, [ebx+fas_header.output]
|
|
call copy_asciiz_escaped
|
|
; 6b. Write ": ".
|
|
stdcall alloc_in_buf, 2
|
|
mov word [edi+ebx], ': '
|
|
inc edi
|
|
inc edi
|
|
; 6c. Copy input name.
|
|
mov [.names], edi
|
|
mov esi, [ebx+fas_header.input]
|
|
call copy_asciiz_escaped
|
|
; 7. Scan for 'include' dependencies.
|
|
; 7a. Get range for scanning.
|
|
mov edx, [ebx+fas_header.preproc_size]
|
|
mov esi, [ebx+fas_header.preproc_offs]
|
|
add edx, esi
|
|
.include_loop:
|
|
; 7b. Loop over preprocessed lines in the range.
|
|
cmp esi, edx
|
|
jae .include_done
|
|
; 7c. For every line, ignore header and do internal loop over tokens.
|
|
add esi, preproc_line_header.contents
|
|
.include_loop_int:
|
|
; There are five types of tokens:
|
|
; 1) "start preprocessor data" with code ';' <byte length> <length*byte token>
|
|
; 2) "quoted string" with code '"' <dword length> <length*byte string>
|
|
; 3) "word" with code 1Ah <byte length> <length*byte word>
|
|
; 4) one-byte tokens like "+", "(" and so on
|
|
; 5) "end-of-line" token with code 0.
|
|
mov al, [esi+ebx]
|
|
inc esi
|
|
; 7d. First, check token type parsing the first byte.
|
|
; For preprocessor tokens, continue to 7e.
|
|
; For quoted strings, go to 7g.
|
|
; For words, go to 7h.
|
|
; For end-of-line, exit the internal loop, continue the external loop.
|
|
; Otherwise, just continue the internal loop.
|
|
cmp al, ';'
|
|
jnz .notprep
|
|
; 7e. For "include" tokens length=7, token is "include", the next token is
|
|
; quoted string.
|
|
; These tokens are handled in 7f, other preprocessor tokens in 7g.
|
|
cmp byte [esi+ebx], 7
|
|
jnz .notinclude
|
|
cmp dword [esi+ebx+1], 'incl'
|
|
jnz .notinclude
|
|
cmp dword [esi+ebx+5], 'ude"'
|
|
jnz .notinclude
|
|
; 7f. Skip over end of this token and the type byte of the next token;
|
|
; this gives the pointer to length-prefixed string, which should be added
|
|
; to dependencies. Note that doing that skips that string,
|
|
; so after copying just continue the internal loop.
|
|
add esi, 9
|
|
call add_separator
|
|
call copy_name_escaped
|
|
jmp .include_loop_int
|
|
.quoted:
|
|
; 7g. To skip a word, load the dword length and add it to pointer.
|
|
add esi, [esi+ebx]
|
|
add esi, 4
|
|
jmp .include_loop_int
|
|
.notinclude:
|
|
; 7h. To skip this token, load the byte length and add it to pointer.
|
|
; Note that word tokens and preprocessor tokens have a similar structure,
|
|
; so both are handled here.
|
|
movzx eax, byte [esi+ebx]
|
|
lea esi, [esi+eax+1]
|
|
jmp .include_loop_int
|
|
.notprep:
|
|
cmp al, 1Ah
|
|
jz .notinclude
|
|
cmp al, '"'
|
|
jz .quoted
|
|
test al, al
|
|
jnz .include_loop_int
|
|
jmp .include_loop
|
|
.include_done:
|
|
; 8. Scan for 'file' dependencies.
|
|
; 8a. Get range for scanning.
|
|
; Note that fas_header.asm_size can be slighly greater than the
|
|
; real size, so we break from the loop when there is no space left
|
|
; for the entire asm_row structure, not when .asm_size is exactly reached.
|
|
mov esi, [ebx+fas_header.asm_offs]
|
|
mov edx, [ebx+fas_header.asm_size]
|
|
add edx, esi
|
|
sub edx, asm_row.sizeof
|
|
push edx
|
|
jc .file_done
|
|
.file_loop:
|
|
; 8b. Loop over assembled lines in the range.
|
|
cmp esi, [esp]
|
|
ja .file_done
|
|
; 8c. For every assembled line, skip "word" and one-byte tokens
|
|
; scanning for three predefined word tokens.
|
|
; Note that lines like "a:b:c:d file 'something'" are possible and valid.
|
|
; go to 8d for token 'file',
|
|
; go to 8e for token 'format',
|
|
; go to 8f for token 'section',
|
|
; continue the loop otherwise.
|
|
mov eax, [esi+ebx+asm_row.preproc_offs]
|
|
add eax, [ebx+fas_header.preproc_offs]
|
|
; We save/restore esi since it is used for another thing in the internal loop;
|
|
; we push eax, which currently contains ebx-relative pointer to
|
|
; preproc_line_header, to be able to access it from resolve_name.
|
|
push esi eax
|
|
.file_tokens_loop:
|
|
mov cl, byte [eax+ebx+preproc_line_header.contents]
|
|
cmp cl, 1Ah
|
|
jnz .file_noword_token
|
|
movzx ecx, byte [eax+ebx+preproc_line_header.contents+1]
|
|
cmp cl, 4
|
|
jnz .file_no_file
|
|
cmp dword [eax+ebx+preproc_line_header.contents+2], 'file'
|
|
jnz .file_no_file4
|
|
; 8d. For lines starting with 'file' token, loop over tokens and get names.
|
|
; Note that there can be several names in one line.
|
|
; Parsing of tokens is similar to step 5 with the difference that
|
|
; preprocessor token stops processing: 'file' directives are processed
|
|
; in assembler stage.
|
|
lea esi, [eax+preproc_line_header.contents+6]
|
|
.file_loop_int:
|
|
mov al, [esi+ebx]
|
|
inc esi
|
|
test al, al
|
|
jz .file_next
|
|
cmp al, ';'
|
|
jz .file_next
|
|
cmp al, 1Ah
|
|
jz .fileword
|
|
cmp al, '"'
|
|
jnz .file_loop_int
|
|
call resolve_name
|
|
add esi, [esi+ebx-4]
|
|
jmp .file_loop_int
|
|
.fileword:
|
|
movzx eax, byte [esi+ebx]
|
|
lea esi, [esi+eax+1]
|
|
jmp .file_loop_int
|
|
.file_no_file4:
|
|
cmp dword [eax+ebx+preproc_line_header.contents+2], 'data'
|
|
jnz .file_word_token
|
|
jmp .file_scan_from
|
|
.file_no_file:
|
|
cmp cl, 6
|
|
jnz .file_no_format
|
|
cmp dword [eax+ebx+preproc_line_header.contents+2], 'form'
|
|
jnz .file_no_format
|
|
cmp word [eax+ebx+preproc_line_header.contents+6], 'at'
|
|
jnz .file_no_format
|
|
; 8e. For lines starting with 'format' token, loop over tokens and look for stub name.
|
|
; Note that there can be another quoted string, namely file extension;
|
|
; stub name always follows the token 'on'.
|
|
mov edx, TokenOn
|
|
call scan_after_word
|
|
jmp .file_next
|
|
.file_no_format:
|
|
cmp cl, 7
|
|
jnz .file_no_section
|
|
cmp dword [eax+ebx+preproc_line_header.contents+2], 'sect'
|
|
jnz .file_no_section
|
|
mov edx, dword [eax+ebx+preproc_line_header.contents+6]
|
|
and edx, 0FFFFFFh
|
|
cmp edx, 'ion'
|
|
jnz .file_no_section
|
|
.file_scan_from:
|
|
mov edx, TokenFrom
|
|
call scan_after_word
|
|
jmp .file_next
|
|
.file_no_section:
|
|
.file_word_token:
|
|
lea eax, [eax+ecx+2]
|
|
jmp .file_tokens_loop
|
|
.file_noword_token:
|
|
inc eax
|
|
test cl, cl
|
|
jz .file_next
|
|
cmp cl, 3Bh
|
|
jz .file_next
|
|
cmp cl, 22h
|
|
jnz .file_tokens_loop
|
|
.file_next:
|
|
pop eax esi
|
|
add esi, asm_row.sizeof
|
|
jmp .file_loop
|
|
.file_done:
|
|
pop edx
|
|
; 9. Write result.
|
|
; 9a. Append two newlines to the end of buffer.
|
|
stdcall alloc_in_buf, 2
|
|
mov word [edi+ebx], 10 * 101h
|
|
inc edi
|
|
inc edi
|
|
; 9b. If '-e' option was given, duplicate dependencies list as fake goals
|
|
; = copy all of them and append ":\n\n".
|
|
cmp [.flags], 0
|
|
jz .nodup
|
|
lea ecx, [edi+1]
|
|
mov esi, [.names]
|
|
sub ecx, esi
|
|
stdcall alloc_in_buf, ecx
|
|
add esi, ebx
|
|
add edi, ebx
|
|
rep movsb
|
|
mov byte [edi-3], ':'
|
|
mov word [edi-2], 10 * 101h
|
|
sub edi, ebx
|
|
.nodup:
|
|
; 9c. Write to output file.
|
|
mov eax, [.outstart]
|
|
sub edi, eax
|
|
add eax, ebx
|
|
call write
|
|
; 10. Exit.
|
|
xor eax, eax
|
|
call exit
|
|
|
|
; Helper procedure for steps 8e and 8f of main algorithm.
|
|
; Looks for quoted strings after given word in edx.
|
|
scan_after_word:
|
|
push esi eax
|
|
lea esi, [eax+preproc_line_header.contents+2+ecx]
|
|
.loop:
|
|
xor ecx, ecx
|
|
.loop_afterword:
|
|
mov al, [esi+ebx]
|
|
inc esi
|
|
test al, al
|
|
jz .loop_done
|
|
cmp al, ';'
|
|
jz .loop_done
|
|
cmp al, 1Ah
|
|
jz .word
|
|
cmp al, '"'
|
|
jnz .loop
|
|
test ecx, ecx
|
|
jz .skip_quoted
|
|
call resolve_name
|
|
.loop_done:
|
|
pop eax esi
|
|
ret
|
|
.skip_quoted:
|
|
add esi, [esi+ebx]
|
|
add esi, 4
|
|
jmp .loop
|
|
.word:
|
|
movzx ecx, byte [esi+ebx]
|
|
lea esi, [esi+ecx+1]
|
|
cmp cl, byte [edx]
|
|
jnz .loop
|
|
push esi edi
|
|
add esi, ebx
|
|
sub esi, ecx
|
|
lea edi, [edx+1]
|
|
repz cmpsb
|
|
pop edi esi
|
|
jnz .loop
|
|
dec ecx
|
|
jmp .loop_afterword
|
|
|
|
; Helper procedure for step 6 of the main procedure.
|
|
; Copies the ASCIIZ name from strings section to the buffer.
|
|
copy_asciiz_escaped:
|
|
add esi, [ebx+fas_header.strings_offs]
|
|
.loop:
|
|
mov al, [esi+ebx]
|
|
test al, al
|
|
jz .nothing
|
|
call copy_char_escaped
|
|
jmp .loop
|
|
.nothing:
|
|
ret
|
|
|
|
; Helper procedure for step 7 of the main procedure.
|
|
; Copies the name with known length to the buffer.
|
|
copy_name_escaped:
|
|
mov ecx, [esi+ebx]
|
|
add esi, 4
|
|
test ecx, ecx
|
|
jz .nothing
|
|
push ecx
|
|
.loop:
|
|
mov al, [esi+ebx]
|
|
call copy_char_escaped
|
|
dec dword [esp]
|
|
jnz .loop
|
|
pop ecx
|
|
.nothing:
|
|
ret
|
|
|
|
; Helper procedure for steps 7 and 8 of the main procedure.
|
|
; Writes separator of file names in output = " \\\n".
|
|
add_separator:
|
|
stdcall alloc_in_buf, 3
|
|
mov word [edi+ebx], ' \'
|
|
mov byte [edi+ebx+2], 10
|
|
add edi, 3
|
|
ret
|
|
|
|
; Helper procedure for step 7 of the main procedure.
|
|
; Resolves the path to 'file' dependency and copies
|
|
; the full name to the buffer.
|
|
resolve_name:
|
|
; FASM uses the following order to search for referenced files:
|
|
; * path of currently assembling file, which may be .asm or .inc
|
|
; * paths from %INCLUDE% for versions >= 1.70
|
|
; * current directory = file name is taken as is, without prepending dir name
|
|
; We mirror this behaviour, trying to find an existing file somewhere.
|
|
; There can be following reasons for the file can not be found anywhere:
|
|
; * it has been deleted between compilation and our actions
|
|
; * it didn't exist at all, compilation has failed
|
|
; * we are running in environment different from fasm environment.
|
|
; Assume that the last reason is most probable and that invalid dependency
|
|
; is better than absent dependency (it is easier to fix an explicit error
|
|
; than a silent one) and output file name without prepending dir name,
|
|
; as in the last case. Actually, we even don't need to test existence
|
|
; of the file in the current directory.
|
|
add esi, 4 ; skip string length
|
|
; 1. Get ebx-relative pointer to preproc_line_header, see the comment in start.7d
|
|
mov eax, [esp+4]
|
|
; 2. Get the path to currently processing file.
|
|
push esi
|
|
.getpath:
|
|
test byte [eax+ebx+preproc_line_header.line_number+3], 80h
|
|
jz @f
|
|
mov eax, [eax+ebx+preproc_line_header.line_offset]
|
|
add eax, [ebx+fas_header.preproc_offs]
|
|
jmp .getpath
|
|
@@:
|
|
mov edx, [eax+ebx+preproc_line_header.source_name]
|
|
test edx, edx
|
|
jz .frommain
|
|
add edx, [ebx+fas_header.preproc_offs]
|
|
jmp @f
|
|
.frommain:
|
|
mov edx, [ebx+fas_header.input]
|
|
add edx, [ebx+fas_header.strings_offs]
|
|
@@:
|
|
; 3. Check that it is not a duplicate of the previous dependency.
|
|
; 3a. Compare preprocessor units.
|
|
cmp edx, [start.prevfilefrom]
|
|
jnz .nodup
|
|
; 3b. Compare string lengths.
|
|
mov eax, [start.prevfile]
|
|
mov ecx, [eax+ebx-4]
|
|
cmp ecx, [esi+ebx-4]
|
|
jnz .nodup
|
|
; 3c. Compare string contents.
|
|
push esi edi
|
|
lea edi, [eax+ebx]
|
|
add esi, ebx
|
|
rep cmpsb
|
|
pop edi esi
|
|
jnz .nodup
|
|
; 3d. It is duplicate, just return.
|
|
pop esi
|
|
ret
|
|
.nodup:
|
|
; 3e. It is not duplicate. Output separator.
|
|
mov [start.prevfilefrom], edx
|
|
mov [start.prevfile], esi
|
|
call add_separator
|
|
; 4. Cut the last component of the path found in step 2.
|
|
mov ecx, edx
|
|
mov esi, edx
|
|
.scanpath:
|
|
mov al, [edx+ebx]
|
|
test al, al
|
|
jz .scandone
|
|
cmp al, '/'
|
|
jz .slash
|
|
cmp al, '\'
|
|
jnz .scannext
|
|
.slash:
|
|
lea ecx, [edx+1]
|
|
.scannext:
|
|
inc edx
|
|
jmp .scanpath
|
|
.scandone:
|
|
sub ecx, esi
|
|
; 5. Try path found in step 4. If found, go to step 8.
|
|
mov [start.testname], edi
|
|
stdcall copy_string, esi, ecx
|
|
pop esi
|
|
call expand_environment
|
|
call test_file_exists
|
|
test eax, eax
|
|
jns .found
|
|
call revert_testname
|
|
; 6. Try each of include paths. For every path, if file is found, go to step 8.
|
|
; Otherwise, continue loop over include path.
|
|
; Skip this step before 1.70.
|
|
cmp [ebx+fas_header.major], 1
|
|
ja .checkenv
|
|
jb .nocheckenv
|
|
cmp [ebx+fas_header.minor], 70
|
|
jb .nocheckenv
|
|
.checkenv:
|
|
mov ecx, [start.include]
|
|
.includeloop_ext:
|
|
mov eax, ecx
|
|
.includeloop_int:
|
|
cmp byte [eax+ebx], 0
|
|
jz @f
|
|
cmp byte [eax+ebx], ';'
|
|
jz @f
|
|
inc eax
|
|
jmp .includeloop_int
|
|
@@:
|
|
push eax
|
|
sub eax, ecx
|
|
jz @f
|
|
stdcall copy_string, ecx, eax
|
|
cmp byte [edi+ebx-1], '/'
|
|
jz .hasslash
|
|
@@:
|
|
stdcall alloc_in_buf, 1
|
|
mov byte [edi+ebx], '/'
|
|
inc edi
|
|
.hasslash:
|
|
call expand_environment
|
|
call test_file_exists
|
|
pop ecx
|
|
test eax, eax
|
|
jns .found
|
|
call revert_testname
|
|
cmp byte [ecx+ebx], 0
|
|
jz .notfound
|
|
inc ecx
|
|
cmp byte [ecx+ebx], 0
|
|
jnz .includeloop_ext
|
|
.nocheckenv:
|
|
.notfound:
|
|
; 7. File not found neither near the current preprocessor unit nor in %INCLUDE%.
|
|
; Assume that it is in the current directory.
|
|
call expand_environment
|
|
.found:
|
|
; 8. Currently we have file name from [start.testname] to edi;
|
|
; it is zero-terminated and not space-escaped. Fix both issues.
|
|
dec edi
|
|
inc [start.free]
|
|
push esi
|
|
mov edx, [start.testname]
|
|
.escapeloop:
|
|
cmp edx, edi
|
|
jae .escapedone
|
|
cmp byte [edx+ebx], ' '
|
|
jnz .noescape
|
|
stdcall alloc_in_buf, 1
|
|
mov ecx, edi
|
|
sub ecx, edx
|
|
push edi
|
|
add edi, ebx
|
|
lea esi, [edi-1]
|
|
std
|
|
rep movsb
|
|
cld
|
|
pop edi
|
|
inc edi
|
|
mov byte [edx+ebx], '\'
|
|
inc edx
|
|
.noescape:
|
|
inc edx
|
|
jmp .escapeloop
|
|
.escapedone:
|
|
pop esi
|
|
ret
|
|
|
|
; Helper procedure for resolve_name.
|
|
; Allocates space in the buffer and appends the given string to the buffer.
|
|
copy_string:
|
|
mov eax, [esp+8]
|
|
test eax, eax
|
|
jz .nothing
|
|
stdcall alloc_in_buf, eax
|
|
mov ecx, [esp+4]
|
|
.copy:
|
|
mov al, [ecx+ebx]
|
|
inc ecx
|
|
cmp al, '\'
|
|
jnz @f
|
|
mov al, '/'
|
|
@@:
|
|
mov [edi+ebx], al
|
|
inc edi
|
|
dec dword [esp+8]
|
|
jnz .copy
|
|
.nothing:
|
|
ret 8
|
|
|
|
; Helper procedure for resolve_name. Undoes appending of last file name.
|
|
revert_testname:
|
|
add [start.free], edi
|
|
mov edi, [start.testname]
|
|
sub [start.free], edi
|
|
ret
|
|
|
|
; Helper procedure for resolve_name. Copies string from esi to edi,
|
|
; expanding environment variables.
|
|
expand_environment:
|
|
; 1. Save esi to restore it in the end of function.
|
|
push esi
|
|
; 2. Push string length to the stack to be used as a variable.
|
|
pushd [esi+ebx-4]
|
|
; 3. Scan loop.
|
|
.scan:
|
|
; 3a. Scan for '%' sign.
|
|
call find_percent
|
|
.justcopy:
|
|
; 3b. Copy the part from the beginning of current portion to '%' sign,
|
|
; advance pointer to '%' sign, or end-of-string if no '%' found.
|
|
push eax
|
|
sub eax, esi
|
|
stdcall copy_string, esi, eax
|
|
pop esi
|
|
; 3c. If string has ended, break from the loop.
|
|
cmp dword [esp], 0
|
|
jz .scandone
|
|
; 3d. Advance over '%' sign.
|
|
inc esi
|
|
dec dword [esp]
|
|
; 3e. Find paired '%'.
|
|
call find_percent
|
|
; 3f. If there is no paired '%', just return to 3b and copy remaining data,
|
|
; including skipped '%'; after that, 3c would break from the loop.
|
|
dec esi
|
|
cmp dword [esp], 0
|
|
jz .justcopy
|
|
; 3g. Otherwise, get the value of environment variable.
|
|
; Since get_environment_variable requires zero-terminated string
|
|
; and returns zero-terminated string, temporarily overwrite trailing '%'
|
|
; and ignore last byte in returned string.
|
|
; Also convert any backslashes to forward slashes.
|
|
inc esi
|
|
mov byte [eax+ebx], 0
|
|
push eax
|
|
push edi
|
|
call get_environment_variable
|
|
dec edi
|
|
inc [start.free]
|
|
pop eax
|
|
.replaceslash:
|
|
cmp eax, edi
|
|
jz .replaceslash_done
|
|
cmp byte [eax+ebx], '\'
|
|
jnz @f
|
|
mov byte [eax+ebx], '/'
|
|
@@:
|
|
inc eax
|
|
jmp .replaceslash
|
|
.replaceslash_done:
|
|
pop esi
|
|
mov byte [esi+ebx], '%'
|
|
; 3h. Advance over trailing '%'.
|
|
inc esi
|
|
dec dword [esp]
|
|
; 3i. Continue the loop.
|
|
jmp .scan
|
|
.scandone:
|
|
; 4. Zero-terminate resulting string.
|
|
stdcall alloc_in_buf, 1
|
|
mov byte [edi+ebx], 0
|
|
inc edi
|
|
; 5. Pop stack variable initialized in step 2.
|
|
pop eax
|
|
; 6. Restore esi saved in step 1 and return.
|
|
pop esi
|
|
ret
|
|
|
|
; Helper procedure for expand_environment.
|
|
; Scans the string in esi with length [esp+4]
|
|
; until '%' is found or line ended.
|
|
find_percent:
|
|
mov eax, esi
|
|
cmp dword [esp+4], 0
|
|
jz .nothing
|
|
.scan:
|
|
cmp byte [eax+ebx], '%'
|
|
jz .nothing
|
|
inc eax
|
|
dec dword [esp+4]
|
|
jnz .scan
|
|
.nothing:
|
|
ret
|
|
|
|
; Helper procedure for copy_{name,asciiz}_escaped.
|
|
; Allocates space and writes one character, possibly escaped.
|
|
copy_char_escaped:
|
|
cmp al, ' '
|
|
jnz .noescape
|
|
stdcall alloc_in_buf, 1
|
|
mov byte [edi+ebx], '\'
|
|
inc edi
|
|
.noescape:
|
|
stdcall alloc_in_buf, 1
|
|
mov al, [esi+ebx]
|
|
inc esi
|
|
cmp al, '\'
|
|
jnz @f
|
|
mov al, '/'
|
|
@@:
|
|
mov [edi+ebx], al
|
|
inc edi
|
|
ret
|
|
|
|
; Helper procedure for ensuring that there is at least [esp+4]
|
|
; free bytes in the buffer.
|
|
alloc_in_buf:
|
|
mov eax, [esp+4]
|
|
sub [start.free], eax
|
|
jb .need_realloc
|
|
ret 4
|
|
.need_realloc:
|
|
mov eax, [start.allocated]
|
|
add eax, eax
|
|
push ecx edx
|
|
call realloc
|
|
pop edx ecx
|
|
cmp [start.free], 0
|
|
jl .need_realloc
|
|
mov ebx, [start.buf]
|
|
ret 4
|
|
|
|
badfile:
|
|
mov esi, badfile_string
|
|
call sayerr
|
|
mov al, 1
|
|
call exit
|
|
|
|
information:
|
|
mov esi, information_string
|
|
call sayerr
|
|
mov al, 2
|
|
call exit
|
|
|
|
nomemory:
|
|
mov esi, nomemory_string
|
|
call sayerr
|
|
mov al, 3
|
|
call exit
|
|
|
|
in_openerr:
|
|
mov esi, in_openerr_string
|
|
jmp in_err
|
|
readerr:
|
|
mov esi, readerr_string
|
|
in_err:
|
|
call sayerr
|
|
mov al, 4
|
|
call exit
|
|
|
|
out_openerr:
|
|
mov esi, out_openerr_string
|
|
jmp out_err
|
|
writeerr:
|
|
mov esi, writeerr_string
|
|
out_err:
|
|
call sayerr
|
|
mov al, 5
|
|
call exit
|
|
|
|
; Platform-specific procedures.
|
|
match =WINDOWS,OS { include 'windows_sys.inc' }
|
|
match =LINUX,OS { include 'linux_sys.inc' }
|
|
|
|
; Data
|
|
macro string a, [b] {
|
|
common
|
|
db a ## _end - a
|
|
a db b
|
|
a ## _end:
|
|
}
|
|
|
|
string information_string, 'Usage: fasmdep [-e] [<input.fas> [<output.Po>]]',10
|
|
string badfile_string, 'Not .fas file',10
|
|
string nomemory_string, 'No memory',10
|
|
string in_openerr_string, 'Cannot open input file',10
|
|
string readerr_string, 'Read error',10
|
|
string out_openerr_string, 'Cannot create output file',10
|
|
string writeerr_string, 'Write error',10
|
|
|
|
include_variable db 'INCLUDE',0
|
|
TokenOn db 2,'on'
|
|
TokenFrom db 4,'from'
|