Optimizing a script that switches function arguments in code files

Question

I made a quick script, that inputs file paths(made for C files), function names and 2 indexes. The script goes over all of the files and switches the indexes of the 2 functions. e.g.:

Running the following code:

python switch_args.py temp_funct 0 1 tmp.c

If tmp.c contains this code:

int my_func(a, b, c, d)

after the execution of the script it would have this code:

int my_func(b, a, c, d)

Code:

https://github.com/martin-varbanov96/toolboxz/blob/master/switch_function_args/switch_args.py:

import argparse
import re

parser = argparse.ArgumentParser()
parser.add_argument("function_name", type=str,
                    help="function name whose arguments will be switched")
parser.add_argument("index", type=int,
                    help="first argument to be switched")
parser.add_argument("destination", type=int,
                    help="second argument to be switched")
parser.add_argument('files', metavar='files', type=str, nargs='+',
                    help='files in which function arguments will be switched')

args = parser.parse_args()
def switch_function_args(func_name, args, index=0, destination=1, ):
    function_call_pattern = "{}[^\)]+".format(func_name)
    for file in args:
        has_function = False
        file_content = ""
        with open(file, "r") as f:
            file_content = f.read()
            if(func_name in file_content):
                has_function = True
        if(has_function):
            for current_function_structure in re.findall(function_call_pattern, file_content):
                current_arguments = re.split("\(", current_function_structure)[1]
                current_arguments = re.split(",", current_arguments)

                # switch arguments
                current_arguments[index], current_arguments[destination] = current_arguments[destination], current_arguments[index]
                fixed_arguments = ",".join(current_arguments)
                fixed_function_structure = "{}({}".format(func_name, fixed_arguments)
                old_struct_pattern = current_function_structure.replace("(", "\(")
                file_content = re.sub(old_struct_pattern, fixed_function_structure, file_content)
            with open(file, "w") as f:
                f.write(file_content)
                
switch_function_args(args.function_name, args.files, index=args.index, destination=args.destination)

Question:

How can this code be optimized for performance?

EDIT:

what is the consistency of the following code and is it a good idea to ignore it?

with open(file, "r") as f_read:
    # code
    with open(file, "w") as f_write:
        # code

Just... why? Why are you doing this? Code generation is, on its own, rarely called for; and code modification even more rare. — Reinderien
– Reinderien, Commented Jan 2, 2021 at 0:28
Imagine you are using a C function in 20 files. At some point you want your function to do more than it used to do, so you would have to change the input parameters of the function. This has happened to me a couple of times and I think that having functions which add, remove or switch arguments would be helpful. — Harton
– Harton, Commented Jan 2, 2021 at 7:50
I see; so this is a refactoring tool. At this point most IDEs worth using are able to do this; see for example CLion's signature change feature. — Reinderien
– Reinderien, Commented Jan 2, 2021 at 14:45
Regarding your edit, it's good practice to have something like this: with open(file, "r") as f_read, open(file, "w") as f_write: ... # code — Grajdeanu Alex
– Grajdeanu Alex, Commented Jan 3, 2021 at 10:46

Reinderien · Accepted Answer · 2021-01-02 20:03:32Z

General

C function arguments are only passed by position and not by name. As such, any attempt to make this modify real code is likely to break callers, and it's possible for that breakage to be silent during compile-time if the exchanged parameters have the same type. That makes this kind of refactoring deeply ill-advised. You're better off using the built-in signature refactoring feature of (pick any grown-up IDE).

Early continuation

Consider rewriting

        if(func_name in file_content):
            has_function = True

as

if func_name not in file_content:
    continue

Note that the parens have been dropped; you don't need a flag variable; and you can de-indent the rest of the loop.

Fragility

Before asking

How can this code be optimized for performance?

you need to make it correct, and it definitely isn't right now for all cases. Functions in C are easily (and fairly often) aliased by pointer, and these aliases will not be modified if the pointer doesn't have the same name as the original function. Following such aliases would only reasonably be done by calling into an existing C parser like Clang/LLVM, which you should probably be doing anyway for robustness.

for the "early continuation" what worries me is the result from with open(file, "r") as f: with open(file, "w") as f: Sorry I can not write proper code here. I will make an Edit. What is the consistency of the stacking 2 context managers which are opening the same file? — Harton
– Harton, Commented Jan 3, 2021 at 6:09
That depends. In your case you should be able to delete your second open, change the first to open in combined read-write mode, and after your read (and before your write), truncate the file. — Reinderien
– Reinderien, Commented Jan 8, 2021 at 2:15

Stack Exchange Network

Optimizing a script that switches function arguments in code files

Code:

Question:

EDIT:

1 Answer 1

General

Early continuation

Fragility

You must log in to answer this question.

Hot Network Questions

Optimizing a script that switches function arguments in code files

Code:

Question:

EDIT:

1 Answer 1

General

Early continuation

Fragility

You must log in to answer this question.

Related

Hot Network Questions