自动从C源代码中删除未使用的局部变量

发布于 2024-07-14 07:54:47 字数 381 浏览 13 评论 0原文

我想从 C 文件中删除未使用的局部变量。示例：

int fun(int a , int b)
{
  int c,sum=0;
  sum=a + b;
    return sum;
}

此处未使用的变量是“c”。

我将在外部拥有所有未使用的局部变量的列表。现在使用我拥有的未使用的局部变量，我们必须从源代码中找到局部变量& 删除。
在上面的示例中，“c”是未使用的变量。我会知道的（我有代码）。在这里我必须找到c& 删除它。

编辑

重点不是使用外部工具查找未使用的局部变量。重点是从给定它们列表的代码中删除它们。

原文

I want to delete unused local variables from C file.
Example:

int fun(int a , int b)
{
  int c,sum=0;
  sum=a + b;
    return sum;
}

Here the unused variable is 'c'.

I will externally have a list of all unused local variables. Now using unused local variables which I have, we have to find local variables from source code & delete.
In above Example "c" is unused variable. I will be knowing it (I have code for that).
Here I have to find c & delete it .

EDIT

The point is not to find unused local variables with an external tool. The point is to remove them from code given a list of them.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

谢绝鈎搭 2024-07-21 07:54:47

打开你的编译器警告级别，它应该会告诉你。

将源片段放入“fc”中：

% gcc -c -Wall f.c
f.c: In function 'fun':
f.c:1: warning: unused variable 'c'

Turn up your compiler warning level, and it should tell you.

Putting your source fragment in "f.c":

% gcc -c -Wall f.c
f.c: In function 'fun':
f.c:1: warning: unused variable 'c'

回复收藏 0 原文

全部不再 2024-07-21 07:54:47

棘手 - 您必须为此解析 C 代码。结果必须有多接近？
我的意思的例子：

int a, /* foo */
    b, /* << the unused one */
    c; /* bar */

现在，对于人类来说很明显第二条评论必须被删除。

略有不同：

void test(/* in */ int a, /* unused */ int b, /* out */ int* c);

同样，第二条评论必须删除，这次是 b 之前的评论。

一般来说，您想要解析您的输入，对其进行过滤，并发出除未使用变量的声明之外的所有内容。您的解析器必须保留注释和 #include 语句，但如果您不 #include 标头，则可能无法识别声明（如果使用宏来隐藏声明，则更是如此）。毕竟，您需要标头来决定是否 A * B(); 是函数声明（当 A 是类型时）或乘法（当 A 是变量时）

[编辑] 此外：

即使您知道变量未使用，删除它的正确方法在很大程度上取决于远程上下文。例如，假设

int foo(int a, int b, int c) { return a + b; }

显然 c 未使用。你能把它改成吗？

int foo(int a, int b) { return a + b; }

也许吧，但如果 &foo 存储在 int(*)(int,int,int) 中则不然。这可能会发生在其他地方。如果（且仅当）发生这种情况，您应该将其更改为

int foo(int a, int b, int /*unused*/ ) { return a + b; }

Tricky - you will have to parse C code for this. How close does the result have to be?
Example of what I mean:

int a, /* foo */
    b, /* << the unused one */
    c; /* bar */

Now, it's obvious to humans that the second comment has to go.

Slight variation:

void test(/* in */ int a, /* unused */ int b, /* out */ int* c);

Again, the second comment has to go, the one before b this time.

In general, you want to parse your input, filter it, and emit everything that's not the declaration of an unused variable. Your parser would have to preserve comments and #include statements, but if you don't #include headers it may be impossible to recognize declarations (even more so if macro's are used to hide the declaration). After all, you need headers to decide if A * B(); is a function declaration (when A is a type) or a multiplication (when A is a variable)

[edit] Furthermore:

Even if you know that a variable is unused, the proper way to remove it depends a lot on remote context. For instance, assume

int foo(int a, int b, int c) { return a + b; }

Clearly, c is unused. Can you change it to ?

int foo(int a, int b) { return a + b; }

Perhaps, but not if &foo is stored int a int(*)(int,int,int). And that may happen somewhere else. If (and only if) that happens, you should change it to

int foo(int a, int b, int /*unused*/ ) { return a + b; }

回复收藏 0 原文

北城孤痞 2024-07-21 07:54:47

你为什么要这样做？假设您有一个不错的优化编译器（GCC、Visual Studio 等），无论您是否删除原始示例中的“int c”，二进制输出都不会有任何不同。

如果这只是代码清理，任何最新的 IDE 都会为您提供每个警告的源代码的快速链接，只需单击并删除:)

回复收藏 0 原文

失与倦＂ 2024-07-21 07:54:47

我的回答更多的是对 MSalters 非常彻底的回答的详细评论。
我想说的是，这样的工具既不可能也不可取。

如果您只是想删除对变量的引用，那么您可以编写自己的代码解析器，但它需要区分它所在的函数上下文，例如

int foo(double a, double b)
{
   b = 10.0;
   return (int) b;
}

int bar(double a, double b)
{
   a = 5.00;
   return (int) a;
}

任何简单的解析器都会遇到两个“a”的问题'b' 是未使用的变量。

其次，如果你像 MSalter 一样考虑评论，你会发现人们的评论不一致；

double a;
/*a is designed as a dummy variable*/
double b;

/*a is designed as a dummy variable*/
double a;
double b;

double a; /*a is designed as a dummy variable*/
double b;

因此

，简单地删除未使用的变量将创建孤立的注释，这可以说比不更危险根本不发表评论。

最终，优雅地完成这是一项极其困难的任务，而且无论如何你都会破坏代码。通过自动化该过程，您将使代码变得更糟。

最后，您应该考虑为什么这些变量首先出现在代码中，如果它们被弃用，为什么当它们的所有引用都被删除时它们没有被删除。

My answer is more of an elaborate comment to MSalters' very thorough answer.
I would go beyond 'tricky' and say that such a tool is both impossible and inadvisable.

If you are looking to simply remove the references to the variable, then you could write a code parser of your own, but it would need to distinguish between the function context it is in such as

int foo(double a, double b)
{
   b = 10.0;
   return (int) b;
}

int bar(double a, double b)
{
   a = 5.00;
   return (int) a;
}

Any simple parser would have trouble with both 'a' and 'b' being unused variables.

Secondly, if you consider comments as MSalter has, you'll discover that people do not comment consistently;

double a;
/*a is designed as a dummy variable*/
double b;

/*a is designed as a dummy variable*/
double a;
double b;

double a; /*a is designed as a dummy variable*/
double b;

etc.

So simply removing the unused variables will create orphaned comments, which are arguably more dangerous than not commenting at all.

Ultimately, it is an obscenely difficult task to do elegantly, and you would be mangling code regardless. By automating the process, you would be making the code worse.

Lastly, you should be considering why the variables were in the code in the first place, and if they are deprecated, why they were not deleted when all their references were.

回复收藏 0 原文