c-preprocessor

Is there a command in tcl that is equivalent to C++ #define? I've seen ways to implement "define" using overloading of the proc function, just wanted to know if anyone knows of a more starightforward way Tcl has a mechanism that lets you define aliases to procedures in an interpreter. If you have proc foo {one two three} {do something with $one $two $three} and you find you're always passing $a and $b as the first two arguments, you can write: interp alias {} foo_ab {} foo $a $b And now you can say: foo_ab $d ;# same as "foo $a $b $d" foo_ab $e ;# same as "foo $a $b $e" example: proc foo {one

I have some code that essentially condenses down to #define FOO(a) FOO(std::map<int, int>); But it emits a compile error (too many actual parameters for macro FOO ). Obviously the preprocessor is thinking that I've supplied std::map<int and int> as arguments. Is there a way round this? The preprocessor will not treat a quoted string with a comma in this way. This should perhaps ideally be a comment, but SO doesn't support code in comments, so, you can do #include <map> #define T_ARGS( ... ) < __VA_ARGS__ > #define FOO( a ) a x; auto main() -> int { FOO( std::map T_ARGS( int, int ) ); (void) x;

If I define a constant in my C .h file: #define constant 1 How do I access it in my assembly .s file? If you use the GNU toolchain, gcc will by default run the preprocessor on files with the .S extension (uppercase 'S'). So you can use all cpp features in your assembly file. There are some caveats: there might be differences in the way the assembler and the preprocessor tokenize the input. If you #include header files, they should only contain preprocessor directives, not C stuff like function prototypes. You shouldn't use # comments, as they would be interpreted by the preprocessor. Example:

One can remove all calls to printf() using #define printf . What if I have a lot of debug prints like std::cout << x << endl; ? How can I quickly switch off cout << statements in a single file using preprocessor? NullStream can be a good solution if you are looking for something quick that removes debug statements. However I would recommend creating your own class for debugging, that can be expanded as needed when more debug functionality is required: class MyDebug { std::ostream & stream; public: MyDebug(std::ostream & s) : stream(s) {} #ifdef NDEBUG template<typename T> MyDebug & operator<<

The man page for gcc states file.s Assembler code. file.S file.sx Assembler code that must be preprocessed. And many standard include files have #ifndef __ASSEMBLY__ ... #endif wrappers to allow inclusion from assembly files. I could have sworn I've written programs before with gcc and it defined this when assembling, but now I'm running into problems. Here's some test code: test.S #include <sys/syscall.h> #include <asm/signal.h> .intel_syntax noprefix .text .global foo // int foo(int pid) foo: mov esi,SIGUSR1 mov eax,SYS_kill syscall ret When I run gcc -c test.S , it complains about all kinds