Getting rid of repeated "Use of unititialized value $foo in pattern match" errors in big set of substitutions

I have a Perl script that builds a hash of symbols from C source files that are longer than X characters, then substitutes a string of A[0-9]{5}. The number increments with each successive symbol to be shortened. This is to prepare the code to be compiled on very old compilers with strange limits on the lengths of symbols.

In https://stackoverflow.com/questions/76544979, I was able to get the old external sed script approach translated to work (mostly) directly in Perl. The problem now is that I'm getting a complaint of

Use of uninitialized value within %transformations in substitution iterator at src/misc/snavig.pl line 210, <> line 8.

around 1600 times. The problem is in this chunk of code, which applies the substitutions:

  my $oldsymbols = join '|', keys %transformations;
  my $oldfilenames = join '|', keys %includes;
  local $^I = '.bak';
  local @ARGV = glob("*.c *.h");
  while (<>) {
    s/\b($oldsymbols)\b/$transformations{$1}/g;
    s/($oldfilenames)/$includes{$1}/g;
    print;
  }

The %transformations hash looks something like this:

hide_lines => 'A00058'
message => 'A00165'
tokenise_text => 'A00388'
z_print_addr => 'A00220'
z_ret_popped => 'A00236'
encode_text => 'A00384'

I've tracked this down to the first part of the substitution matching on the entire line and it's put into $1. So of course compression_names[compression_mode], hide_lines); won't appear as a key in that hash. What I don't get is how to guard the $oldfilenames string such that $1 will only receive one of the symbols in that string. The substitutions in %includes doesn't provoke a complaint because the entire line will always match a key.

I don't remember where I found a suggestion to guard it with \K ... (?=.) or \K ... (?=.*) both in and out of the \b things. These either did nothing or made messes. What's the correct and effective way to get rid of those complaints?

Editing to add sample data:

Before processing:

/*
 * print_char
 *
 * High level output function.
 *
 */
void print_char(zchar c)
{
        static bool flag = FALSE;
        need_newline_at_exit = TRUE;

        if (message || ostream_memory || enable_buffering) {
                if (!flag) {
                        /* Characters 0 and ZC_RETURN are special cases */
                        if (c == ZC_RETURN) {
                                new_line();
                                return;
                        }

After processing:

/*
 * A00267
 *
 * High level output function.
 *
 */
void A00267(zchar c)
{
        static bool flag = FALSE;
        A00174 = TRUE;

        if (A00165 || A00162 || A00173) {
                if (!flag) {
                        /* Characters 0 and ZC_RETURN are special cases */
                        if (c == ZC_RETURN) {
                                A00266();
                                return;
                        }

Making substitutions within commented-out areas is fine.

There's information missing from your post, or some of the information is incorrect. (If this doesn't answer your question, you need to provide an actual demonstration of the problem.)

I'm guessing the issue is that you have keys with special symbols in them. For example, consider the case where you have a key named foo*. That will match foo (among others), which might not be in your hash.

You can verify that this is the issue by adding the following:

if ( my @errors = sort grep /\W/, keys %transformations ) {
   die(
      join "",
         map "Transformation key `$_` contains non-word symbols\n",
            @errors
   );
}

If that's intentional, you can replace

my $oldsymbols = join '|', keys %transformations;

with

my $oldsymbols = join '|', map quotemeta, keys %transformations;

But note that the anchoring \b won't behave as desired if a key starts or ends with a non-word character.

> I've tracked this down to the first part of the substitution matching on the entire line and it's put into $1.

Your regex isn't matching complete lines, unless there is something in your real code that you haven't shown us.

I don't see a problem when running this

my %transformations = (
    hide_lines    => 'A00058',
    message       => 'A00165',
    tokenise_text => 'A00388',
    z_print_addr  => 'A00220',
    z_ret_popped  => 'A00236',
    encode_text   => 'A00384',
  );


my $oldsymbols = join '|', keys %transformations;
while (<DATA>) {
    s/\b($oldsymbols)\b/$transformations{$1}/g;
    print;
}


__END__

hide_lines
message
tokenise_text

compression_names[compression_mode], hide_lines);

It does the right thing

$ perl try.pl 

A00058
A00165
A00388

compression_names[compression_mode], A00058);

Can you update the question please?