checking string

[simeonz]

If you can stand the non-conventional (by contemporary standards) interface, you can use Emacs for your development. It can be hacked into doing most things. Its Lisp-like scripting language has virtually no restrictions. But the design is a bit heavy and messy for my taste. Another option is to write plug-in for another IDE, like Eclipse, Code::Blocks, Qt designer (if you use Qt). Indeed, many IDEs are trying to make your life easier - comment sections, fold, re-factor. May be it is just because the authors lack the horsepower to support every utility imaginable. When you think about it, many IDEs do not even support syntax checking on the fly, or re-factoring, so stuff has to happen slowly. Not to state the obvious, but you can contact particular development team, or write a change request in their bug tracking system, and they will tell you if they make it priority for the following builds.

Regards

EDIT: Also, I find this interesting http://www.cplusplus.com/reference/clibrary/cstdlib/div/

[alfa333]

Thanks.

you can contact particular development team, or write a change request in their bug tracking system

- do you know the URL for that regarding gcc or dev-C++?

The rest of my issues can be considered done. I am happy to hear about http://www.cplusplus.com/reference/clibrary/cstdlib/div/ - this confirms that at least some of my ideas are good (because they were found worth implementing, even I did not pass them to appropriate persons when they arose).

[simeonz]

I don't recommend that you use the div function though. It is inherited from C, and the compiler technology was not the same back than. This code:

    volatile int x = 0;
    volatile int y = 1;
    int a = x;
    int b = y;
    div_t r = div(a, b);
    return r.quot + r.rem;

results in the following output from g++ -O2 -S -fverbose-asm -masm=intel:

	mov	DWORD PTR [esp+28], 0	 # x,
	mov	DWORD PTR [esp+24], 1	 # y,
	mov	eax, DWORD PTR [esp+28]	 # a, x
	mov	edx, DWORD PTR [esp+24]	 # b, y
	mov	DWORD PTR [esp+4], edx	 #, b
	mov	DWORD PTR [esp], eax	 #, a
	call	_div	 #
	lea	eax, [edx+eax]	 # tmp65,

You can see calling a routine, with pushing arguments on the stack and everything. This is not faster than simply using the built-in operations one after another. There is something nice - the quotient and divisor are returned in the registers eax and edx. Apparently this is how gcc returns 8 byte structure on a 32-bit platform with the cdecl calling convention.

do you know the URL for that regarding gcc or dev-C++?

Not really. I browse archives and bug tracking records, but have not submitted myself. It should not be that hard to find how to do it.

Regards

[alfa333]

Thanks, simeonz. No more questions as yet.