stack-overflow

I have been reading "The Shellcoders Handbook" and been referring to this link for practice of stack overflow. But it seems the Linux kernel developers have made the kernel very secure. Here are my problems. 1) This code void function(int a, int b, int c) { char buffer1[8]; char buffer2[10]; int* ret; ret = buffer1 + 6; *ret+=8; } void main() { int x; x = 0; function(1,2,3); x = 1; printf("%d\n",x); } gives the output $ cc smash.c smash.c: In function ‘function’: smash.c:7:8: warning: assignment from incompatible pointer type $ ./a.out 1 but replacing the line *ret+=8 with *ret=8 gives the

Apologies for not abstracting this problem in a dedicated test case, I hope the example from a real project is simple enough to describe the problem. I have a JavaEE/JPA2/JSF web application where every @Entity Element (or subclass) has a templated view.xhtml page, and a standard link generator composite component util:view_link.xhtml, invoked as GET with database ID as parameter. A portion (only) of each view page represents an expert system summary; that portion can be abstracted as a composite component, for inclusion in a view page or elsewhere. I have introduced a Primefaces p:dialog

While running this code it shows Stackoverflow error. What is it I am doing wrong, why does the code compile? public class Foo { int a = 5; Foo f = new Foo(); void go() { System.out.println(f.a); } public static void main(String[] args) { Foo f2 = new Foo(); f2.go(); } } You can call go method with an instance only. so before call to go started, c'tor has run for class Foo Now, C'tor is designed to initialize all instance members. So one by one it initializes: a is initialized to 5 f is initialized to an Object // but here is the catch, f never gets initilized. before = operator works, C'tor

What are the usual causes of "Error C stack overflow" in the Hugs Haskell implementation. This can come up if you are used to functional languages in which it is common to do tail-recursion factorization. Say you have a function: sum = go 0 where go accum [] = accum go accum (x:xs) = go (accum+x) xs Which, incidentally, is the same as sum = foldl (+) 0 If we evaluate the function we can see the problem: sum [1,2,3,4] go 0 [1,2,3,4] go (0+1) [2,3,4] go ((0+1)+2) [3,4] go (((0+1)+2)+3) [4] go ((((0+1)+2)+3)+4) [] (((0+1)+2)+3)+4 Now to evaluate that expression Haskell uses a stack: EXPR | STACK

I'm playing with closures and seeing this odd behavior that I can't quite explain: groovy:000> ({ println owner })() groovysh_evaluate@200b6145 ===> null groovy:000> ({ println "${owner}" })() groovysh_evaluate@2bf75a70 ===> null groovy:000> ({ ({ println owner })() })() groovysh_evaluate$_run_closure1@10f67a01 ===> null groovy:000> ({ ({ println "${owner}" })() })() ERROR java.lang.StackOverflowError: null at groovysh_evaluate$_run_closure1_closure2.doCall (groovysh_evaluate:2) at groovysh_evaluate$_run_closure1_closure2.doCall (groovysh_evaluate) at groovysh_evaluate$_run_closure1.doCall

Originated from this question , I have this little F# code ( github ) to generate random values according to a normal distribution: // val nextSingle : (unit -> float32) let nextSingle = let r = System.Random() r.NextDouble >> float32 // val gauss : (float32 -> float32 -> seq<float32>) let gauss mean stdDev = let rec gauss ready = seq { match ready with | Some spare -> yield spare * stdDev + mean yield! gauss None | _ -> let rec loop () = let u = nextSingle() * 2.f - 1.f let v = nextSingle() * 2.f - 1.f let s = pown u 2 + pown v 2 if s >= 1.f || s = 0.f then loop() else u, v, s let u, v, s =