Re: undefining one slot of a typeglob

I have worked a lot with changes of the symbol table for Safe::World, and looking in the replies that your node got, I think that none of them are the best way.

Well, say that my way is better is easy, soo I will show what happens in the 3 different types:

DELETING FROM THE TABLE:

    my $d = *{ 'main::destination::' };
    delete $d->{foo};
[download]

This will just remove all the entry from the table, but wont ensure that the sub reference was really removed from the memory. Making test of full deletion of packages for Safe::World, is easy to see that if you don't undef explicity a reference from the memory it will stay there even if you clean the HASH of the symbol table.

But one of the problems here is that you remove all the references, soo, if you have a $foo and &foo, you will erase both.

undef

Just make a undef to the &sub actually works, but you will still have a *foo{CODE} value in the GLOB, what will use memory.

Note that undef is the standar way to do that, and is the recomended way, but you won't have the GLOB exactly as you have it before set the sub.

Symbol::gensym

In Perl is impossible to create a GLOB that exists only in the scope. Soo, gensym() creates a new GLOB at Symbol::GENx, where x is a number. Soo, it won't be cleanned when you go out of the scope. Again you will be just duplicating everything.

local()

Since a GLOB really need to be in the symbol table, local(*FOO) will create a GLOB that replaces the already existing GLOB in the symbol table for the given scope. Soo, after go out of the scope, the previous will be back. The biggest problem is when you make references to the local(*GLOB) after go out of the scope. Soo, if you make local(*FOO), and want to make something like a closure of it to $holder = \*FOO, it won't work.

Also for recursion or loop codes, the last local(*FOO) will change the previous sets.

NOW MAKEING A UNDO TO A GLOB:

Is easy, we just create a holder for the different types inside the GLOB, make a undef, than reset the values, unless the removed type:

  *FOO = sub { print "SUB FOO OK!\n" } ;
  $FOO = 123 ;

  print ">>>>>>>>>> BEFORE RM:\n" ;
  
  eval{ FOO() } ; warn($@) if $@ ;
  print "CODE: " . *FOO{CODE} . "\n" ;
  print "SCALAR: $FOO\n" ;
  
  glob_rm( \*FOO , 'CODE' ) ;
  
  print ">>>>>>>>>> AFTER RM:\n" ;
  
  eval{ FOO() } ; warn($@) if $@ ;
  print "CODE: " . *FOO{CODE} . "\n" ;
  print "SCALAR: $FOO\n" ;

sub glob_rm {
  my $glob = shift ;
  my $type = uc( shift(@_) ) ;

  my %holder ;
  foreach my $tp ( qw(SCALAR ARRAY HASH CODE IO FORMAT) ) {
    $holder{$tp} = *{$glob}{$tp} if $tp ne $type ;
  }
  
  if    ($type eq 'SCALAR') { undef ${*{$glob}} ;}
  elsif ($type eq 'ARRAY')  { undef @{*{$glob}} ;}
  elsif ($type eq 'HASH')   { undef %{*{$glob}} ;}
  elsif ($type eq 'CODE')   { undef &{*{$glob}} ;}
  elsif ($type eq 'IO')     { close *{$glob} ;}
  
  undef *{$glob} ;
  
  foreach my $Key ( keys %holder ) { *{$glob} = $holder{$Key} ;}
}
[download]

This will print:

>>>>>>>>>> BEFORE RM:
SUB FOO OK!
CODE: CODE(0x1a72bac)
SCALAR: 123
>>>>>>>>>> AFTER RM:
Undefined subroutine &main::FOO called at tmp.pl line 17.
CODE: 
SCALAR: 123
[download]

Note that this approach is to remove a reference type of a GLOB. If you want to overwrite one of the types, the best is to just set the GLOB with a reference.

Actually all of this depends of what you need. If you wan't speed, use just undef &FOO, but if you want to save memory I recomend the glob_rm() function.

Enjoy! ;-P

Graciliano M. P.
"Creativity is the expression of the liberty".

Comment on Re: undefining one slot of a typeglob Select or Download Code

Replies are listed 'Best First'.
Re: Re: undefining one slot of a typeglob by AidanLee (Chaplain) on Feb 24, 2004 at 06:15 UTC
it didn't occur to me that i didn't have to use a typeglob as my holder. good idea, and although it's a core module, this approach means i have one less use statement. Can anybody tell me why do this: `if ($type eq 'SCALAR') { undef ${{$glob}} ;} elsif ($type eq 'ARRAY') { undef @{{$glob}} ;} elsif ($type eq 'HASH') { undef %{{$glob}} ;} elsif ($type eq 'CODE') { undef &{{$glob}} ;} elsif ($type eq 'IO') { close {$glob} ;}` [download] instead of this: `($type eq 'IO') ? close {$glob} : undef {$glob}{$type};` [download] and i have to wonder if just using this would not work: `undef {$glob}{$type};` [download] update: I should note that completely eradicating the sub from memory isn't necessarily the problem here, as sometimes the created CODE glob is simply an alias from another package rather than a brand new anonymous sub.	[reply] [d/l] [select]
Re: Re: Re: undefining one slot of a typeglob by gmpassos (Priest) on Feb 24, 2004 at 08:24 UTC
If I'm not wrong we can't change a glob key/element, only access it. Soo, this won't work: `undef {$glob}{$type} ;` [download] And I make this: `if ($type eq 'SCALAR') { undef ${{$glob}} ;} elsif ($type eq 'ARRAY') { undef @{{$glob}} ;} elsif ($type eq 'HASH') { undef %{{$glob}} ;} elsif ($type eq 'CODE') { undef &{{$glob}} ;} elsif ($type eq 'IO') { close {$glob} ;}` [download] Not to remove the element from the GLOB, but to ensure that it goes out of the memory, since undef *{$glob} already remove all the keys/elements. Actually for your needs you can remove all the if ( $type eq '...' ). Graciliano M. P. "Creativity is the expression of the liberty".	[reply] [d/l] [select]
Re: Re: undefining one slot of a typeglob by ysth (Canon) on Feb 24, 2004 at 16:12 UTC
Symbol::gensym In Perl is impossible to create a GLOB that exists only in the scope. Soo, gensym() creates a new GLOB at Symbol::GENx, where x is a number. Soo, it won't be cleanned when you go out of the scope. Again you will be just duplicating everything. Symbol::gensym does create its symbols in the Symbol:: package, but then removes them from the package, so when a returned symbol goes out of scope it does get garbage collected. If you think you get a leak doing this, report it as a bug, with a short test case. Also, your undefs of each type (and close of the file handle) should never be needed; if you can come up with a short test case that shows a problem, please report this as a perl bug also.	[reply]
Re: Re: Re: undefining one slot of a typeglob by gmpassos (Priest) on Feb 24, 2004 at 20:00 UTC
"Symbol::gensym does create its symbols in the Symbol:: package, but then removes them from the package, so when a returned symbol goes out of scope it does get garbage collected" Are you sure about that? I can guarantee to you that it won't make garbage collection! First because we don't have any note about that in the POD of Symbol, and because gensym() just return a reference of a GLOB in the package Symbol::, and any GLOB reference doesn't have scope, since it's a GLOBAL "object". The best way is to see the source of gensym(): `sub gensym () { my $name = "GEN" . $genseq++; my $ref = \{$genpkg . $name}; delete $$genpkg{$name}; $ref; }` [download] Soo, when the $ref goes out, the GLOB still exists in the package Symbol::. Here's a test of that: `{ my $glob = gensym() ; ${$glob} = 123 ; print "SCOPED: " . "${$glob}\n" ; } print "OUT: " . ${Symbol::GEN0} . "\n";` [download] And the output: `SCOPED: 123 OUT: 123` [download] About the undef of types, well, this was already discussed here in PM, and is all about memory usage. If we make a undef in all the different types of a GLOB to clean a package from the memory, we will free much more memory than just make a undef GLOB. And the memory difference is big. In my tests after 1000 executions I have the interpreter with 8Mb, and with the simple undef GLOBS I have 150Mb! Graciliano M. P. "Creativity is the expression of the liberty".	[reply] [d/l] [select]
Re: Re: Re: Re: undefining one slot of a typeglob by ysth (Canon) on Feb 25, 2004 at 01:28 UTC
`{ my $glob = gensym() ; ${$glob} = 123 ; print "SCOPED: " . "${$glob}\n" ; } print "OUT: " . ${Symbol::GEN0} . "\n";` [download] I don't think you quite understand what that is doing. At compile time, that Symbol::GEN0 in the OUT line causes the GEN0 glob to be created and referred to directly by the compiled code. Then at runtime, gensym fetches and deletes it from the symbol table (skipping creating it since it's already there). Adding to your test: `use Symbol; print "Symbols: ", join(",",keys %Symbol::), "\n"; { my $glob = gensym() ; ${$glob} = 123 ; print "SCOPED: " . "${$glob}\n" ; } print "OUT: " . ${*Symbol::GEN0} . "\n"; print "Symbols2: ", join(",",keys %Symbol::), "\n"; print "OUT2: ", ${"Symbol::GEN0"} . "\n";` [download] gets you: `Symbols: qualify,geniosym,gensym,GEN0,EXPORT,EXPORT_OK,import,ungensym +,qualify_to_ref,EXPORT_FAIL,delete_package,ISA,BEGIN,VERSION SCOPED: 123 OUT: 123 Symbols2: qualify,geniosym,gensym,EXPORT,EXPORT_OK,import,ungensym,qua +lify_to_ref,EXPORT_FAIL,delete_package,ISA,BEGIN,VERSION OUT2:` [download] About the undef of types, I don't remember ever seeing your actual tests, and I wasn't able to deduce anything useful from your Safe::World. If undefing the individual parts of the glob is freeing more than undefing the whole glob, it is a bug and sample code showing it in action would be very welcome.	[reply] [d/l] [select]
Re: Re: Re: Re: undefining one slot of a typeglob by ambrus (Abbot) on Feb 25, 2004 at 15:31 UTC
I think the symbol gets garbage collected on newer Perls, but on older ones, you must explicitly ungensym it. Update: Yes, here's what it says: from perldoc Symbol: "Symbol::gensym" creates an anonymous glob and returns a reference to it. Such a glob reference can be used as a file or directory handle. For backward compatibility with older implementations that didn't support anonymous globs, "Symbol::ungensym" is also provided. But it doesn't do anything.	[reply]


go ahead... be a heretic
	PerlMonks