argument-passing

It seems state-of-art compilers treat arguments passed by stack as read-only. Note that in the x86 calling convention, the caller pushes arguments onto the stack and the callee uses the arguments in the stack. For example, the following C code: extern int goo(int *x); int foo(int x, int y) { goo(&x); return x; } is compiled by clang -O3 -c g.c -S -m32 in OS X 10.10 into: .section __TEXT,__text,regular,pure_instructions .macosx_version_min 10, 10 .globl _foo .align 4, 0x90 _foo: ## @foo ## BB#0: pushl %ebp movl %esp, %ebp subl $8, %esp movl 8(%ebp), %eax movl %eax, -4(%ebp) leal -4(%ebp), %eax

Since: irb --help Usage: irb.rb [options] [programfile] [arguments] I know I can pass arguments to ARGV if I include a programfile eg: irb test.rb A B C where test.irb is simply "p ARGV" produces: ["a", "b", "c"] Making programfile be con in DOS... I can do following irb con A B C con(main):001:0> ARGV produces: ARGV => ["A", "B", "C"] but this is system dependent and has the side effect of echoing input :-( What i really like is something like irb -- a b c BTW: I know I can set ARGV inside irb but I my intention is to alias special == irb -rSpecialLibrary" so I can do something like: special

I have some task to solve and the most important part at the moment is to make the script as time-efficient as possible. One of the elements I am trying to optimize is memoization within one of the functions. So my question is: Which of the following 3-4 methods is the most efficient / fastest method of implementing memoization in Python? I have provided code only as an example - if one of the methods is more efficient, but not in the case I mentioned, please share what you know. Solution 1 - using mutable variable from outer scope This solution is often shown as the example memoization, but I

How do I pass all the arguments of one shell script into another? I have tried $*, but as I expected, that does not work if you have quoted arguments. Example: $ cat script1.sh #! /bin/sh ./script2.sh $* $ cat script2.sh #! /bin/sh echo $1 echo $2 echo $3 $ script1.sh apple "pear orange" banana apple pear orange I want it to print out: apple pear orange banana Use "$@" instead of $* to preserve the quotes: ./script2.sh "$@" More info: http://tldp.org/LDP/abs/html/internalvariables.html $* All of the positional parameters, seen as a single word Note: "$*" must be quoted. $@ Same as $*, but each

I've got a function that takes a pointer to an object of a custom class (actually pointers to a base class such that polymorphism works). Within the calling routine this object however is exclusively needed for the purpose of this call, i.e. is temporary. For example like this: class A { /** stuff */ }; class B : public A { /** stuff */ }; void doSomething( const A* const _p ) { /** stuff */ } void callingRoutine() { A* tempPointer = new B; doSomething( tempPointer ); delete tempPointer; } Now, since I really only need the object of type B within the call to doSomething , is there a way to do

I am using windows 7 I want to pass filename as argument which I want to open through custom url. I followed link http://msdn.microsoft.com/en-us/library/aa767914(v=vs.85).aspx My python code is: import os,sys selectedFileName=(sys.argv)[1] os.startfile(selectedFileName) My registry setting is: Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Classes\cultest] @="\"URL:cultest Protocol\"" "URL Protocol"="\"\"" [HKEY_LOCAL_MACHINE\SOFTWARE\Classes\cultest\DefaultIcon] [HKEY_LOCAL_MACHINE\SOFTWARE\Classes\cultest\shell] [HKEY_LOCAL_MACHINE\SOFTWARE\Classes\cultest\shell\open]