Quickbasic 4.5 compiler output

Hello,

After having created an executable with qb45, I would like
to be able to compare the new executable with an older one
made sometime before(code verification). I attempted this
by using the dos file compare (fc) command. I used a hex
editor to compare the two executables. On nearly each subsequent
run I found that there were individual byte differences occurring.
Sometimes, it would be only a couple bit differences in several
different bytes. I already determined that the date-time stamp
is not at issue, as I compiled, then recompiled another day with
the exact same results.

My goal is to compare the newly compiled executable qb45 file, with
the 'known good' pre-existing executable.

So, with the forementioned information, my questions:

Why are the executables different? Is this due to different versions
of DOS environments with their associated macros in which the original
compile and subsequent compiles were performed?


Also, since the executables are different, is there some precompile
operations that can be performed like a RAM block fill or something
to properly initialize memory space?

I have thought of doing a running histogram by comparing byte by byte
the differences that occur between the old and new compiled files.
This would at least give me some information as to the nature of what's
really going on. But if someone out there knows the qb45 compile and
link environment, knows the answers to these questions, I would like
to know about it.

thank you for your time.

Z man


Comments

  • : Hello,
    :
    : After having created an executable with qb45, I would like
    : to be able to compare the new executable with an older one
    : made sometime before(code verification). I attempted this
    : by using the dos file compare (fc) command. I used a hex
    : editor to compare the two executables. On nearly each subsequent
    : run I found that there were individual byte differences occurring.
    : Sometimes, it would be only a couple bit differences in several
    : different bytes. I already determined that the date-time stamp
    : is not at issue, as I compiled, then recompiled another day with
    : the exact same results.
    :
    : My goal is to compare the newly compiled executable qb45 file, with
    : the 'known good' pre-existing executable.
    :
    : So, with the forementioned information, my questions:
    :
    : Why are the executables different? Is this due to different versions
    : of DOS environments with their associated macros in which the original
    : compile and subsequent compiles were performed?
    :
    :
    : Also, since the executables are different, is there some precompile
    : operations that can be performed like a RAM block fill or something
    : to properly initialize memory space?
    :
    : I have thought of doing a running histogram by comparing byte by byte
    : the differences that occur between the old and new compiled files.
    : This would at least give me some information as to the nature of what's
    : really going on. But if someone out there knows the qb45 compile and
    : link environment, knows the answers to these questions, I would like
    : to know about it.
    :
    : thank you for your time.
    :
    : Z man
    :
    :
    :
    What is your goal here? That would help greatly in answering your questions.
    ET

  • : : Hello,
    : :
    : : After having created an executable with qb45, I would like
    : : to be able to compare the new executable with an older one
    : : made sometime before(code verification). I attempted this
    : : by using the dos file compare (fc) command. I used a hex
    : : editor to compare the two executables. On nearly each subsequent
    : : run I found that there were individual byte differences occurring.
    : : Sometimes, it would be only a couple bit differences in several
    : : different bytes. I already determined that the date-time stamp
    : : is not at issue, as I compiled, then recompiled another day with
    : : the exact same results.
    : :
    : : My goal is to compare the newly compiled executable qb45 file, with
    : : the 'known good' pre-existing executable.
    : :
    : : So, with the forementioned information, my questions:
    : :
    : : Why are the executables different? Is this due to different versions
    : : of DOS environments with their associated macros in which the original
    : : compile and subsequent compiles were performed?
    : :
    : :
    : : Also, since the executables are different, is there some precompile
    : : operations that can be performed like a RAM block fill or something
    : : to properly initialize memory space?
    : :
    : : I have thought of doing a running histogram by comparing byte by byte
    : : the differences that occur between the old and new compiled files.
    : : This would at least give me some information as to the nature of what's
    : : really going on. But if someone out there knows the qb45 compile and
    : : link environment, knows the answers to these questions, I would like
    : : to know about it.
    : :
    : : thank you for your time.
    : :
    : : Z man
    : :
    : :
    : :
    : What is your goal here? That would help greatly in answering your questions.
    : ET
    :
    :
    Hello,

    the goal is to be able to compare a previously compiled executable file with a new one, provided the same, identical source
    code.

    So, one would think that the new compiled executable should be the
    identical provided that you use the same version of qb45, same linker version same DOS versions, ect. However, this is NOT happening.

    Z man



    I originally attempted this via a DOS file compare command
    and the two were not identical. I need to know why this is so.



  • : : : Hello,
    : : :
    : : : After having created an executable with qb45, I would like
    : : : to be able to compare the new executable with an older one
    : : : made sometime before(code verification). I attempted this
    : : : by using the dos file compare (fc) command. I used a hex
    : : : editor to compare the two executables. On nearly each subsequent
    : : : run I found that there were individual byte differences occurring.
    : : : Sometimes, it would be only a couple bit differences in several
    : : : different bytes. I already determined that the date-time stamp
    : : : is not at issue, as I compiled, then recompiled another day with
    : : : the exact same results.
    : : :
    : : : My goal is to compare the newly compiled executable qb45 file, with
    : : : the 'known good' pre-existing executable.
    : : :
    : : : So, with the forementioned information, my questions:
    : : :
    : : : Why are the executables different? Is this due to different versions
    : : : of DOS environments with their associated macros in which the original
    : : : compile and subsequent compiles were performed?
    : : :
    : : :
    : : : Also, since the executables are different, is there some precompile
    : : : operations that can be performed like a RAM block fill or something
    : : : to properly initialize memory space?
    : : :
    : : : I have thought of doing a running histogram by comparing byte by byte
    : : : the differences that occur between the old and new compiled files.
    : : : This would at least give me some information as to the nature of what's
    : : : really going on. But if someone out there knows the qb45 compile and
    : : : link environment, knows the answers to these questions, I would like
    : : : to know about it.
    : : :
    : : : thank you for your time.
    : : :
    : : : Z man
    : : :
    : : :
    : : :
    : : What is your goal here? That would help greatly in answering your questions.
    : : ET
    : :
    : :
    : Hello,
    :
    : the goal is to be able to compare a previously compiled executable file with a new one, provided the same, identical source
    : code.
    :
    : So, one would think that the new compiled executable should be the
    : identical provided that you use the same version of qb45, same linker version same DOS versions, ect. However, this is NOT happening.
    :
    : Z man
    :
    :
    :
    : I originally attempted this via a DOS file compare command
    : and the two were not identical. I need to know why this is so.
    :
    :
    :
    :
    Is the file size the same?

  • : : : : Hello,
    : : : :
    : : : : After having created an executable with qb45, I would like
    : : : : to be able to compare the new executable with an older one
    : : : : made sometime before(code verification). I attempted this
    : : : : by using the dos file compare (fc) command. I used a hex
    : : : : editor to compare the two executables. On nearly each subsequent
    : : : : run I found that there were individual byte differences occurring.
    : : : : Sometimes, it would be only a couple bit differences in several
    : : : : different bytes. I already determined that the date-time stamp
    : : : : is not at issue, as I compiled, then recompiled another day with
    : : : : the exact same results.
    : : : :
    : : : : My goal is to compare the newly compiled executable qb45 file, with
    : : : : the 'known good' pre-existing executable.
    : : : :
    : : : : So, with the forementioned information, my questions:
    : : : :
    : : : : Why are the executables different? Is this due to different versions
    : : : : of DOS environments with their associated macros in which the original
    : : : : compile and subsequent compiles were performed?
    : : : :
    : : : :
    : : : : Also, since the executables are different, is there some precompile
    : : : : operations that can be performed like a RAM block fill or something
    : : : : to properly initialize memory space?
    : : : :
    : : : : I have thought of doing a running histogram by comparing byte by byte
    : : : : the differences that occur between the old and new compiled files.
    : : : : This would at least give me some information as to the nature of what's
    : : : : really going on. But if someone out there knows the qb45 compile and
    : : : : link environment, knows the answers to these questions, I would like
    : : : : to know about it.
    : : : :
    : : : : thank you for your time.
    : : : :
    : : : : Z man
    : : : :
    : : : :
    : : : :
    : : : What is your goal here? That would help greatly in answering your questions.
    : : : ET
    : : :
    : : :
    : : Hello,
    : :
    : : the goal is to be able to compare a previously compiled executable file with a new one, provided the same, identical source
    : : code.
    : :
    : : So, one would think that the new compiled executable should be the
    : : identical provided that you use the same version of qb45, same linker version same DOS versions, ect. However, this is NOT happening.
    : :
    : : Z man
    : :
    : :
    : :
    : : I originally attempted this via a DOS file compare command
    : : and the two were not identical. I need to know why this is so.
    : :
    : :
    : :
    : :
    : Is the file size the same?
    :
    :

  • : : : : : Hello,
    : : : : :
    : : : : : After having created an executable with qb45, I would like
    : : : : : to be able to compare the new executable with an older one
    : : : : : made sometime before(code verification). I attempted this
    : : : : : by using the dos file compare (fc) command. I used a hex
    : : : : : editor to compare the two executables. On nearly each subsequent
    : : : : : run I found that there were individual byte differences occurring.
    : : : : : Sometimes, it would be only a couple bit differences in several
    : : : : : different bytes. I already determined that the date-time stamp
    : : : : : is not at issue, as I compiled, then recompiled another day with
    : : : : : the exact same results.
    : : : : :
    : : : : : My goal is to compare the newly compiled executable qb45 file, with
    : : : : : the 'known good' pre-existing executable.
    : : : : :
    : : : : : So, with the forementioned information, my questions:
    : : : : :
    : : : : : Why are the executables different? Is this due to different versions
    : : : : : of DOS environments with their associated macros in which the original
    : : : : : compile and subsequent compiles were performed?
    : : : : :
    : : : : :
    : : : : : Also, since the executables are different, is there some precompile
    : : : : : operations that can be performed like a RAM block fill or something
    : : : : : to properly initialize memory space?
    : : : : :
    : : : : : I have thought of doing a running histogram by comparing byte by byte
    : : : : : the differences that occur between the old and new compiled files.
    : : : : : This would at least give me some information as to the nature of what's
    : : : : : really going on. But if someone out there knows the qb45 compile and
    : : : : : link environment, knows the answers to these questions, I would like
    : : : : : to know about it.
    : : : : :
    : : : : : thank you for your time.
    : : : : :
    : : : : : Z man
    : : : : :
    : : : : :
    : : : : :
    : : : : What is your goal here? That would help greatly in answering your questions.
    : : : : ET
    : : : :
    : : : :
    : : : Hello,
    : : :
    : : : the goal is to be able to compare a previously compiled executable file with a new one, provided the same, identical source
    : : : code.
    : : :
    : : : So, one would think that the new compiled executable should be the
    : : : identical provided that you use the same version of qb45, same linker version same DOS versions, ect. However, this is NOT happening.
    : : :
    : : : Z man
    : : :
    : : :
    : : :
    : : : I originally attempted this via a DOS file compare command
    : : : and the two were not identical. I need to know why this is so.
    : : :
    : : :
    : : :
    : : :
    : : Is the file size the same?
    : :
    : :
    :
    :
    File size is the same. However, this is a very rough indicator
    of file comparison when you have only a very small percentage of
    bytes that differ between the two files.

    Z man
  • Hi,
    I tried making two exe files with the same source. The only difference before compiling was the name of the bas file.
    When I compared the exe files with fc the only difference was the embedded name of the file.

    Hope this helps.
    Pappy
    You learn something new everyday.

Sign In or Register to comment.

Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

Categories