0

For example I want to check whether the following code can be more concise or not:

for(i = 0; i < map->size; i++){
    if(0 < map->bucket[i].n){
        p = map->bucket[i].list;
        while(p){
            h = hash(p->key) % n;
            if(bucket[h].list){
                new_p = bucket[h].list;
                while(new_p->next)new_p = new_p->next;
                new_p->next = p;
                next = p->next;
                p->next = NULL;
                p = p->next;
            }
            else{
                bucket[h].list = p;
                bucket[h].n++;
                next = p->next;
                p->next = NULL;
                p = p->next;
            }   
        }
    }
}

Is there any tool for such kind of task?

It would be of great help to me .

Je Rog
  • 5,675
  • 8
  • 39
  • 47

3 Answers3

3

You could be asking for several things here. One possible interpretation of your question is that you are looking for a slicer, a tool that takes a program and produces a program made of a selection of the instructions from the original program, and that computes some or all of the results of the original. In other words, a slicer removes that instructions that are not necessary for at least one of the results you are interested in.

There is an Open-Source slicer for C programs here.

For making programs more concise, perhaps the constraint of keeping only instructions from the original program as they are is too strong. You may also want to allow some transformations other than "keeping" or "removing". The framework that the slicer linked above is part of provides this kind of transformation too. For instance:

int main(int c, char **v)
{
  int x = 2;
  int y = x + c;
  return y; 
}

In the above program, a slicer instructed to preserve the exit code cannot remove any instruction: they all contribute to the result. But if you first apply a constant propagation, transforming every constant expression in its value:

int main(int c, char **v)
{
  int x = 2;
  int y = 2 + c;
  return y; 
}

Then a slicer can in a second pass remove the useless variable x:

int main(int c, char **v)
{
  int y = 2 + c;
  return y; 
}
Pascal Cuoq
  • 79,187
  • 7
  • 161
  • 281
1

The answer is a qualified "no",

  • No, because it is impossible to write a program that will always answer whether code can be made more concise or not. If such a program could exist, you could use it to create a logical paradox (which is why we know it can't exist).

  • Programs of this nature don't generally exist, because making source code smaller in a mechanical way makes the code less readable. Most programmers just don't see any benefit in making the C code as small as possible.

  • Yes, because you can use static analysis to find dead code.

People put enormous amounts of research into making programs smaller and faster automatically, using static analysis, but nearly all of that research gets applied to making better optimizers for compilers. Optimizers can produce almost unreadable output, which is why we don't use them to produce source code but object code only.

Keep your source code clean and readable. The compiler will take care of the rest, 99% of the time.

Dietrich Epp
  • 205,541
  • 37
  • 345
  • 415
  • **Logically** more concise will only make code more readable IMO. – Je Rog Aug 31 '11 at 15:47
  • @Je Rog: #!/usr/local/bin/perl -s do 'bigint.pl';($_,$n)=@ARGV;s/^.(..)*$/0$&/;($k=unpack('B*',pack('H*',$_)))=~ s/^0*//;$x=0;$z=$n=~s/./$x=&badd(&bmul($x,16),hex$&)/ge;while(read(STDIN,$_,$w =((2*$d-1+$z)&~1)/2)){$r=1;$_=substr($_."\0"x$w,$c=0,$w);s/.|\n/$c=&badd(&bmul ($c,256),ord$&)/ge;$_=$k;s/./$r=&bmod(&bmul($r,$r),$x),$&?$r=&bmod(&bmul($r,$c ),$x):0,""/ge;($r,$t)=&bdiv($r,256),$_=pack(C,$t).$_ while$w--+1-2*$d;print} – Dietrich Epp Aug 31 '11 at 15:58
  • Please post it in good format in the first place. My question is not on format,or beautiful code, but logic conciceness, which all c programmers should care a lot. – Je Rog Aug 31 '11 at 16:03
  • @Dietrich: Is it really impossible to write a program that will always answer whether code can be made more concise or not? It seems to my like it should, but I don't see a (diagonalization-)proof right now. – DaveFar Sep 04 '11 at 08:24
  • @DaveBall: You could use such a program to solve the halting problem. – Dietrich Epp Sep 04 '11 at 15:37
  • That was my first thought, but I don't see it: you can decide whether a program never terminates by reducing it to the most concise one that simply does an infinite loop. But that's not enough for programs having parameters, is it? – DaveFar Sep 04 '11 at 16:33
  • @DaveBall: You are going about this proof in the wrong direction. Start with an arbitrary Turing machine *i* and arbitrary input *x,* then show how the optimizer could be used to determine whether *i* halts on input *x.* Since this is impossible, you know the optimizer does not exist. – Dietrich Epp Sep 04 '11 at 17:02
1

You could try compiling it with optimizations and looking at the optimized assembly code. But then you really aren't gaining anything in terms of speed since the compiler optimized away all the extra stuff anyway. All you gain is an increase in readability.

Daniel
  • 6,595
  • 9
  • 38
  • 70