Ignoring function-scope

Zallus

I'm writing a CMS (well, kinda), and I've been trying to come up with a way to get around ONE level of function scope in a require_once()'d file. The idea is this function getlib ('library_foo') would call 'library_foo/code.php', which would set up some variables, like $num_of_foos for example. These would need to be external to the function scope of getlib, so, for example, getlib ('library_bar'), that depended on library_foo (simply by calling getlib('library_foo')), would be able to use foo's variables.

The actual implementation issue I'm currently facing:

In lib.php:
getlib ('adodb');
getlib ('user');

In ADOdb/code.php:
require ('adodb.inc.php');
$sql = &NewADOConnection (SQL_TYPE);
$sql->Connect (SQL_SERVER, SQL_USER, SQL_PASSWORD, SQL_DATABASE);
...

In user/code.php:
...
$user = $sql->Execute ('select * from ' . SQL_PREFIX . 'users where id = ' $final_user_id);
...

Anyway, once lib.php drops out of "getlib ('adodb');", $sql ceases to exist. What can I do to fix this without, or with minimal obfuscation?

steadyguy

If I understand you correctly, the global directive should do what you want.

Zallus

Well, not really. I can't use global if I don't know what variables the function will load, and I want it to be aware of all the variables, just as if it were executing outside the function's scope. Sure,

foreach ($GLOBALS as $key => $value)
{
$$key = $value;
}

will work for getting the variables, but I also need to modify the variables once I'm done, as well.

Starting -every- variable with $GLOBALS is good too, but a bit more obfuscated than I was looking for.

steadyguy

Then why not do:

function example() {
    foreach($GLOBALS as $key => $value) {
        global $$key;
    }
    //do your stuff, all your global vars are here now: usable, modifiable, and everything
}

Zallus

Okay, that's good for loading any already present variables, but if I declare a new variable, I have to refer to it as $GLOBALS['variable'] for the rest of the script. Is there a more transparent way?

steadyguy

Originally posted by Zallus
... but if I declare a new variable, I have to refer to it as $GLOBALS['variable'] for the rest of the script. Is there a more transparent way?

Actually, you don't. Once a variable is declared global (with either global or the $GLOBALS array), you can refer to it by it's name (ie., $variable). Only catch is that if you're in another function (and thus a new scope), you will need to 'globalize' again (for example, with the code I posted earlier), or use the $GLOBALS array.

Another option that you might want to consider (and now that I think of it, probably a much better one), is passing arguments to your functions - this is a good way to leave the scope barrier intact, but still get around it. Particularly if you pass by reference instead of by value. An extremely basic example:

$x = 1;
function my_increment($var) {
    $var++;
}
//pass argument by value.  $x is still 1
my_increment($x);
//pass argument by reference, $x is now 2
my_increment(&$x);

Zallus

Alright, it looks good in concept, but the function is more of an interface. I'm trying to set it up so you can just call the library, independant of what's acually IN the library, and then reference that library's variables directly from another script, or even another library. Here's my "libs/code.php":

<?php

  # Core Function Library
  # Copyright 2003 Zallus Kanite.

  function getlib ($lib, $version = NULL)
  {
    foreach ($GLOBALS as $key => $value)
    {
      global $$key;
    }

if (empty($library[$lib]))
{
  if (is_string($version))
  {
    $library_name = $lib;
    $library_version = $version;
  }
  else if (is_int($version) || is_float($version))
  {
    $dh  = opendir(LIB_DIR);
    while (false !== ($filename = readdir($dh)))
    {
      $filelist[] = $filename;
    }
    rsort($filelist); reset($filelist);
    foreach ($filelist as $filename)
    {
      if (eregi($library . '-' . $version, $filename))
      {
        $filename = explode('-', $filename);
        $library_name = $filename[0];
        $library_version = $filename[1];
        break;
      }
    }
  }
  else if ($version == NULL)
  {
    $dh  = opendir(LIB_DIR);
    while (false !== ($filename = readdir($dh)))
    {
      $filelist[] = $filename;
    }
    rsort($filelist); reset($filelist);
    foreach ($filelist as $filename)
    {
      if (eregi($lib, $filename))
      {
        $filename = explode('-', $filename);
        $library_name = $filename[0];
        $library_version = $filename[1];
        break;
      }
    }
  }

  $library[$lib] = array('name' => $library_name, 'version' => $library_version, 'path' => LIB_DIR . '/' . $library_name . '-' . $library_version);

  return require_once (LIB_DIR . '/' . $library_name . '-' . $library_version . '/code.php');
}
else
{
  return false;
}
  }

  function verlib ($lib)
  {
    global $library;

if (!empty($library[$lib]))
{
  return $lib . ': ' . $library[$lib]['name'] . '-' . $library[$lib]['version'] . ' active.';
}
else
{
  return $lib . ': inactive.';
}
  }

?>

That's what I've got right now, but it unloads any variables not expected in the function scope. I could do the C thing and prototype any variables, like so:

// In 'main.php';
$sql = array();
$foo = array(); # I like it better than NULL, which doesn't detect.
$bar = array();
getlib('sql', 1.21);
echo $sql . $foo . $bar;

// In 'sql-1.21/code.php';
getlib('foobar', '1.00');
$sql = 'YAY';

// In 'foobar-1.00/code.php';
$foo = 2;
$bar = $sql;

In theory, that'd look nice, but I don't want the people who write one library relying on a constant interface from another library. Maybe another script called 'declare.php' in the directory of the script, that declares a bunch of $GLOBALS['foo'] = array();... If I could avoid it however, a solution that just modifies getlib() would be appreciated.

ahundiak

Might I suggest that you just accept the way php deals with globals and modify your design accordingly? Trying to "force fit" a solution usually does not work well.

Sxooter

$agree_with_ahundiak++;

steadyguy

Or ... perhaps you should look into PHP OOP.