Also the best decompiler is "Reflector for .NET" which is absolutely
free.
We are attempting to educate the developer community regarding new
options available to them regarding low cost and better tools for both
decompilation and obfuscation. I'm sorry that you are threatened by
the competition, but we are happy to compete with you based on product
merits and reproduceable examples, rather than biased opinions. The
reality is that there are many cases including this user's experience
where our product works correctly and runs well without requiring any
preconfiguration prior to obfuscation, where your product and others
do not in both the obfuscator and the decompiler marketplace.
You should try our product before forming an opinion about which
product is best. There is a reason that our product is not free and
our customers have decided to purchase it after having tested both it
and Reflector.
Please try to maintain a level of professionalism and make your claims
based on actual facts that can be substantiated after having actually
examined the products that you claim are not as good. We have sent
Lutz a lot of feedback regarding code generation issues in Reflector
that he has not yet had time to correct. The reality is that our
product generates higher level code which also compiles and runs
correctly which Reflector is unable to accomplish. We can provide many
common examples of both higher level code generation such as goto
elimination in switch statements, and of incorrect code generation by
Reflector where our product generates correct code. There are a lot of
subtle issues related to casting primitive types and manipulating
unsafe code for which other products including Reflector fail to
generate correct code. A good example would be the ILReader library
written by Reflector's author. Our product decompiles, recompiles, and
runs the library correctly while Reflector is unable to do the same
even with a library written by it's own author. We also are the only
decompiler which reads symbol files and retains local variable names.
We also do a much better job with unsafe code and COM Interop and each
release is produced by decompiling and recompiling itself with
obfuscation enabled. Our releases would not even compile or run
correctly if they did not generate correct code.
Here is a simple example that you can try if you don't believe me.
I've included the output from both products in case you are too lazy
to bother running them, but you can verify these statements yourself
by downloading and running our free trial version from
http://www.junglecreatures.com/.
We have reported these bugs and many others to the author of Reflector
the first day that Reflector 4.0 shipped over a month ago and they
have still gone unfixed. We have also reported and posted several
bugs, fixes, and extensions to him regarding his ILReader library.
Here is the original code written by one of our customers:
unsafe static bool unsafePointer(string s) {
char[] c = new char[10];
s.CopyTo(0,c,0,10);
fixed(char *p=c){
*(p+5) = 'x';
for (int i = 0; i < 10; i++)
if (*(p+i) == 'p')
return true;
}
return false;
}
Below is what the latest version of Reflector 4.0.5 does with it.
Reflector's generated code will not compile, and would not run
correctly even if it did because of incorrect pointer arithmetic.
Notice that the generated code is missing the fixed statement. It also
fails to convert the type of the value from 112 back to the char type
in the original code. Also, notice that the assignment local1[10] =
120; generated from *(p+5) = 'x'; assigns the wrong location in the
array because it doesn't account for the size of the pointer object.
private static bool unsafePointer(string s)
{
int num1;
char[] chArray1 = new char[10];
s.CopyTo(0, chArray1, 0, 10);
pinned ref char local1 = ref chArray1[0];
local1[10] = 120;
for (num1 = 0; (num1 < 10); num1 += 1)
{
if ((local1 + (num1 * 2)) == 112)
{
return true;
}
}
local1 = 0;
return false;
}
Now, Here is what Decompiler.NET produces. Notice that not only does
the code compile and run correctly, it retains the original local
variable names and actually improves on the original code by replacing
pointer arithmetic with array references.
static unsafe bool unsafePointer (string s)
{
char[] c;
c = new char[10];
s.CopyTo (0, c, 0, 10);
fixed (char* p = c)
{
p[5] = 'x';
for (int i = 0; (i < 10); i++)
{
if (p
== 'p')
{
return true;
}
}
}
return false;
}
We will be extremely happy to discuss any real examples that you or
anyone else may have that compare our product to competitive products,
free or not, from both a quality and usability standpoint. We also
provide free updates, and much better support than anyone else by
posting improved versions with new features almost daily and we
respond to any customer issues immediately and would post fixed
versions within a day or so if a customer actually identified an
issue. We have a lot of very happy customers and so far, we have
identified any bugs before any of them even encountered them.
Jonathan Pierce
President
Jungle Creatures, Inc.
http://www.junglecreatures.com/
"John Wood" <[email protected]> wrote in message
What kind of weird, twisted, sad advertising is this
above
app and perhaps
I'm
