V. ºÎ·Ï (Appendixes)

Table of Contents
A. Migrating from PHP/FI 2.0 to PHP 3.0
B. PHP development
C. The PHP Debugger


Appendix A. Migrating from PHP/FI 2.0 to PHP 3.0


(¿ªÀÚÁÖ: À̺κÐÀº º°·Î ÀÌ¿ëµÇÁö ¾ÊÀ» °ÍÀ¸·Î »ý°¢µÇ¹Ç·Î ¹ø¿ªÀ» »ý·«ÇÑ´Ù.)

About the incompatbilities in 3.0

PHP 3.0 is rewritten from the ground up. It has a proper parser that is much more robust and consistent than 2.0's. 3.0 is also significantly faster, and uses less memory. However, some of these improvements have not been possible without compatibility changes, both in syntax and functionality.

In addition, PHP's developers have tried to clean up both PHP's syntax and semantics in version 3.0, and this has also caused some incompatibilities. In the long run, we believe that these changes are for the better.

This chapter will try to guide you through the incompatibilities you might run into when going from PHP/FI 2.0 to PHP 3.0 and help you resolve them. New features are not mentioned here unless necessary.

A conversion program that can automatically convert your old PHP/FI 2.0 scripts exists. It can be found in the convertor subdirectory of the PHP 3.0 distribution. This program only catches the syntax changes though, so you should read this chapter carefully anyway.


Start/end tags

The first thing you probably will notice is that PHP's start and end tags have changed. The old <? > form has been replaced by three new possible forms:

Example 0-1. Migration: old start/end tags

<? echo "This is PHP/FI 2.0 code.\n"; >

As of version 2.0, PHP/FI also supports this variation:

Example 0-2. Migration: first new start/end tags

<? echo "This is PHP 3.0 code!\n"; ?>

Notice that the end tag now consists of a question mark and a greater-than character instead of just greater-than. However, if you plan on using XML on your server, you will get problems with the first new variant, because PHP may try to execute the XML markup in XML documents as PHP code. Because of this, the following variation was introduced:

Example 0-3. Migration: second new start/end tags

<?php echo "This is PHP 3.0 code!\n"; ?>

Some people have had problems with editors that don't understand the processing instruction tags at all. Microsoft FrontPage is one such editor, and as a workaround for these, the following variation was introduced as well:

Example 0-4. Migration: third new start/end tags

<script language="php">
  echo "This is PHP 3.0 code!\n";
</script>


if..endif syntax

The `alternative' way to write if/elseif/else statements, using if(); elseif(); else; endif; cannot be efficiently implemented without adding a large amount of complexity to the 3.0 parser. Because of this, the syntax has been changed:

Example 0-5. Migration: old if..endif syntax

if ($foo);
    echo "yep\n";
elseif ($bar);
    echo "almost\n";
else;
    echo "nope\n";
endif;

Example 0-6. Migration: new if..endif syntax

if ($foo):
    echo "yep\n";
elseif ($bar):
    echo "almost\n";
else:
    echo "nope\n";
endif;

Notice that the semicolons have been replaced by colons in all statements but the one terminating the expression (endif).


while syntax

Just like with if..endif, the syntax of while..endwhile has changed as well:

Example 0-7. Migration: old while..endwhile syntax

while ($more_to_come);
    ...
endwhile;

Example 0-8. Migration: new while..endwhile syntax

while ($more_to_come):
    ...
endwhile;

Warning

If you use the old while..endwhile syntax in PHP 3.0, you will get a never-ending loop.


Expression types

PHP/FI 2.0 used the left side of expressions to determine what type the result should be. PHP 3.0 takes both sides into account when determining result types, and this may cause 2.0 scripts to behave unexpectedly in 3.0.

Consider this example:

$a[0]=5;
$a[1]=7;
$key = key($a);
while ("" != $key) {
    echo "$keyn";
    next($a);
}

In PHP/FI 2.0, this would display both of $a's indices. In PHP 3.0, it wouldn't display anything. The reason is that in PHP 2.0, because the left argument's type was string, a string comparison was made, and indeed "" does not equal "0", and the loop went through. In PHP 3.0, when a string is compared with an integer, an integer comparison is made (the string is converted to an integer). This results in comparing atoi("") which is 0, and variablelist which is also 0, and since 0==0, the loop doesn't go through even once.

The fix for this is simple. Replace the while statement with:

while ((string)$key != "") {


Error messages have changed

PHP 3.0's error messages are usually more accurate than 2.0's were, but you no longer get to see the code fragment causing the error. You will be supplied with a file name and a line number for the error, though.


Short-circuited boolean evaluation

In PHP 3.0 boolean evaluation is short-circuited. This means that in an expression like (1 || test_me()), the function test_me() would not be executed since nothing can change the result of the expression after the 1.

This is a minor compatibility issue, but may cause unexpected side-effects.


Function true/false return values

Most internal functions have been rewritten so they return TRUE when successful and FALSE when failing, as opposed to 0 and -1 in PHP/FI 2.0, respectively. The new behaviour allows for more logical code, like $fp = fopen("/your/file") or fail("darn!");. Because PHP/FI 2.0 had no clear rules for what functions should return when they failed, most such scripts will probably have to be checked manually after using the 2.0 to 3.0 convertor.

Example 0-9. Migration from 2.0: return values, old code

$fp = fopen($file, "r");
if ($fp == -1);
    echo("Could not open $file for reading<br>\n");
endif;

Example 0-10. Migration from 2.0: return values, new code

$fp = @fopen($file, "r") or print("Could not open $file for reading<br>\n");


Other incompatibilities

Example 0-11. Migration from 2.0: concatenation for strings

echo "1" + "1";

In PHP 2.0 this would echo 11, in PHP 3.0 it would echo 2. Instead use:

echo "1"."1";
$a = 1;
$b = 1;
echo $a + $b;

This would echo 2 in both PHP 2.0 and 3.0.

$a = 1;
$b = 1;
echo $a.$b;

This will echo 11 in PHP 3.0.

 


Appendix B. PHP development


Adding functions to PHP3


Function Prototype

¸ðµç ÇÔ¼ö´Â ´ÙÀ½°ú °°Àº ¸ð¾çÀ» ÃëÇÑ´Ù. :

void php3_foo(INTERNAL_FUNCTION_PARAMETERS) {
     
}

ºñ·Ï ÇÔ¼ö°¡ ¾î¶² Àμö(argument)µµ °¡Áö°í ÀÖÁö ¾Ê¾Æµµ, ÀÌ·± ¹æ½ÄÀ¸·Î È£ÃâµÈ´Ù.


Function Arguments

Àμö(Argument)´Â ÇÑ»ó pval typeÀÌ´Ù. ÀÌ typeÀº argumentÀÇ actual typeÀ» °¡Áø unionÀ» Æ÷ÇÔÇϰí ÀÖ´Ù. µû¶ó¼­, ¸¸¾à ÇÔ¼ö°¡ µÎ °³ÀÇ argument¸¦ °¡Áø´Ù¸é, ÇÔ¼öÀÇ ¸Ç óÀ½¿¡¼­ ´ÙÀ½°ú °°Àº µ¿ÀÛÀ» ÃëÇÑ´Ù. :

Example 0-1. Fetching function arguments

pval *arg1, *arg2;
if (ARG_COUNT(ht) != 2 || getParameters(ht,2,&arg1,&arg2)==FAILURE) {
   WRONG_PARAM_COUNT;
}

NOTE: argument´Â by value¿Í by referenceÀÇ ¹æ½ÄÁß¿¡ Çϳª·Î Àü´ÞµÈ´Ù. µÎ ¹æ½Ä ¸ðµÎ getParameters¿¡ &(pval *)À» Àü´ÞÇÒ Çʿ䰡 ÀÖ´Ù. ¸¸¿ª ¿©·¯ºÐÀÌ n¹øÂ° parameter°¡ by reference·Î Àü´ÞµÇ¾ú´Â°¡¸¦ °Ë»çÇÏ·Á¸é, ParameterPassedByReference(ht,n) ÇÔ¼ö¸¦ »ç¿ëÇÑ´Ù. ÀÌ ÇÔ¼ö´Â 1À̳ª 0À» ¹ÝȯÇÑ´Ù.

When you change any of the passed parameters, whether they are sent by reference or by value, you can either start over with the parameter by calling pval_destructor on it, or if it's an ARRAY you want to add to, you can use functions similar to the ones in internal_functions.h which manipulate return_value as an ARRAY.

Also if you change a parameter to IS_STRING make sure you first assign the new estrdup()'ed string and the string length, and only later change the type to IS_STRING. If you change the string of a parameter which already IS_STRING or IS_ARRAY you should run pval_destructor on it first.


Variable Function Arguments

A function can take a variable number of arguments. If your function can take either 2 or 3 arguments, use the following:

Example 0-2. Variable function arguments

pval *arg1, *arg2, *arg3;
int arg_count = ARG_COUNT(ht);
if (arg_count < 2 || arg_count > 3 ||
    getParameters(ht,arg_count,&arg1,&arg2,&arg3)==FAILURE) {
    WRONG_PARAM_COUNT;
}


Using the Function Arguments

°³º° argumentÀÇ typeÀº pval type Çʵ忡 ÀúÀåµÈ´Ù. ÀÌ typeÀº ´ÙÀ½Áß ÇÑ °³´Ù. :

Table 0-1. PHP Internal Types

IS_STRING

String

IS_DOUBLE

Double-precision floating point

IS_LONG

Long integer

IS_ARRAY

Array

IS_EMPTY

None

IS_USER_FUNCTION

??

IS_INTERNAL_FUNCTION

?? (if some of these cannot be passed to a function - delete)

IS_CLASS

??

IS_OBJECT

??

If you get an argument of one type and would like to use it as another, or if you just want to force the argument to be of a certain type, you can use one of the following conversion functions:

convert_to_long(arg1);
convert_to_double(arg1);
convert_to_string(arg1); 
convert_to_boolean_long(arg1); /* If the string is "" or "0" it becomes 0, 1 otherwise */
convert_string_to_number(arg1);  /* Converts string to either LONG or DOUBLE depending on string */

These function all do in-place conversion. They do not return anything.

The actual argument is stored in a union; the members are:


Memory Management in Functions

ÇÔ¼ö°¡ ÇÊ¿äÇÑ ¸ðµç ¸Þ¸ð¸®´Â emalloc()À̳ª estrdup()À» »ç¿ëÇØ¼­ È®º¸ÇÑ´Ù. ÀÌ ÇÔ¼öµéÀº ÀϹÝÀûÀÎ malloc(), strdup()°ú ºñ½ÁÇÏ°Ô ´À²¸Áö´Â Ãß»óÀûÀÎ ¸Þ¸ð¸® °ü¸® ÇÔ¼öÀÌ´Ù. ÀÌ ¸Þ¸ð¸®´Â efree()ÇÔ¼ö¸¦ »ç¿ëÇÏ¿© ÇØÁ¦(free)µÈ´Ù.

ÇÁ·Î±×·¥¿¡¼­´Â ´ÙÀ½°ú °°Àº µÎ Á¾·ùÀÇ Á¾·ùÀÇ ¸Þ¸ð¸®°¡ »ç¿ëµÈ´Ù. : º¯¼ö¿¡¼­ »ç¿ëÇÏ¿© ÆÄ¼­¿¡ µ¹·ÁÁö´Â ¸Þ¸ð¸®¿Í, ¿©·¯ºÐÀÇ ³»ºÎ ÇÔ¼ö(internal function)¿¡¼­ Àӽà ÀúÀå °ø°£À¸·Î ÇÊ¿äÇÑ ¸Þ¸ð¸®. ¸¸¾à ¿©·¯ºÐÀÌ ¹®ÀÚ¿­À» ÆÄ¼­¿¡ µ¹·ÁÁÙ º¯¼ö¿¡ ÀúÀåÇÏ·Á ÇÑ´Ù¸é, ÀÌ º¯¼ö´Â ¿ì¼± emalloc()À̳ª estrdup()ÀÇ ÇÔ¼ö¸¦ »ç¿ëÇÏ¿© ¸Þ¸ð¸®ÀÇ °ø°£À» È®º¸ÇÒ Çʿ䰡 ÀÖ´Ù. ÀÌ ¸Þ¸ð¸®´Â Àý´ë ¿©·¯ºÐÀÌ Ç®¾îÁÙ ¼ö ¾ø´Ù. ´ÜÁö, ÈÄ¿¡ °°Àº ÇÔ¼ö³»¿¡¼­ ¿ø·¡ÀÇ ´ëÀÔµÈ °ªÀ» ¹Ù²Ù¾î ÁÙ ¼ö ÀÖÀ» »ÓÀÌ´Ù.

¿©·¯ºÐÀÌ ÇÔ¼ö³ª ¶óÀ̺귯¸®¿¡¼­ ÇÊ¿äÇÑ ¾î¶°ÇÑ ÀÓ½Ã/¿µ±¸ÀûÀÎ ¸Þ¸ð¸®¿¡ ´ëÇØ¼­µµ, ¿©·¯ºÐÀº emalloc()°ú estrdup(), efree()ÀÇ 3°³ÀÇ ÇÔ¼ö¸¦ »ç¿ëÇØ¾ß ÇÑ´Ù. ÀÌ ÇÔ¼öµéÀº ¹Ýµå½Ã ±×°Í¿¡ ´ëÀÀµÇ´Â ÇÔ¼öµé°ú ÇÔ²² ÀÛµ¿ÇØ¾ß ÇÑ´Ù. emalloc()À̳ª estrdup()À» »ç¿ëÇÑ ¸Þ¸ð¸®¿¡´Â, ÀÌ ¸Þ¸ð¸®°¡ ÇÁ·Î±×·¥ÀÌ Á¾·áµÉ ¶§±îÁö ÇÊ¿äÇÑ °ÍÀÌ ¾Æ´Ñ ÇÑ, ¹Ýµå½Ã efree()°¡ ÇÊ¿äÇÏ´Ù. ¸¸¾à ±×·¸°Ô ÇÏÁö ¾ÊÀ¸¸é ¸Þ¸ð¸® ´©¼³(leak)ÀÌ ¹ß»ýÇÑ´Ù. "±× ÇÔ¼ö°¡ ±×°Í¿¡ ´ëÀÀµÇ´Â ÇÔ¼ö¿Í ÇÔ²² ÀÛµ¿ÇØ¾ß ÇÑ´Ù"´Â °ÍÀÇ Àǹ̴Â, emalloc()À̳ª estrdup()¾øÀÌ efree()¸¦ »ç¿ëÇÑ´Ù¸é ¿©·¯ºÐÀº segment fault ¿À·ù¸¦ ¸¸³ª°Ô µÉ °ÍÀÌ´Ù. ±×·¯¹Ç·Î ÇÊ¿ä¾ø´Â ¸Þ¸ð¸®¿¡ ´ëÇÑ ÇØÁ¦´Â ÃæºÐÇÑ ÁÖÀǸ¦ ±â¿ï¿©¾ß ÇÒ °ÍÀÌ´Ù.

PHPÀ» "-DDEBUG"¸¦ ÁÖ°í ÄÄÆÄÀÏÇÏ¿´´Ù¸é, PHP´Â emalloc()À̳ª estrdup()¿¡ ÀÇÇØ È®º¸µÈ ¸ðµç ¸Þ¸ð¸®ÀÇ list¸¦ Ç¥½ÃÇÒ °ÍÀÌ´Ù. ±×·¯³ª, efree()ÇÔ¼ö¸¦ »ç¿ëÇØµµ ÇØÁ¦µÇÁö ¾Ê°í, ÇØ´ç ÇÁ·Î±×·¥ÀÌ Á¾·áµÉ ¶§ ÇØÁ¦µÈ´Ù.


Setting Variables in the Symbol Table

symbol table¿¡ º¯¼ö¸¦ ¼³Á¤Çϱ⠽±°ÔÇϱâ À§ÇØ ´ÙÀ½°ú °°Àº ¸î °³ÀÇ macro°¡ ÀÖ´Ù. :

[1]

PHP 3.0ÀÇ Symbol tablesÀº hash tableÀÇ ÇüÅ·ΠµÇ¾î ÀÖ´Ù. ¾ðÁ¦³ª &symbol_tableÀº 'main' symbol tableÀ» °¡¸®Å°°í ÀÖ°í, active_symbol_tableÀº ÇöÀç activeµÈ symbol tableÀ» °¡¸®Å°°í ÀÖ´Ù. (ÀÌ µÎ°¡Áö´Â ½ÃÀÛ(startup)½Ã´Â °°Áö¸¸, ÇÔ¼ö¾È¿¡¼­´Â ´Þ¶óÁø´Ù.)

The following examples use 'active_symbol_table'. You should replace it with &symbol_table if you specifically want to work with the 'main' symbol table. Also, the same functions may be applied to arrays, as explained below.

Example 0-3. Checking whether $foo exists in a symbol table

if (hash_exists(active_symbol_table,"foo",sizeof("foo"))) { exists... }
else { doesn't exist }

Example 0-4. Finding a variable's size in a symbol table

hash_find(active_symbol_table,"foo",sizeof("foo"),&pvalue);
check(pvalue.type);

Arrays in PHP 3.0 are implemented using the same hashtables as symbol tables. This means the two above functions can also be used to check variables inside arrays.

If you want to define a new array in a symbol table, you should do the following.

First, you may want to check whether it exists and abort appropiately, using hash_exists() or hash_find().

Next, initialize the array:

Example 0-5. Initializing a new array

pval arr;
if (array_init(&arr) == FAILURE) { failed... };
hash_update(active_symbol_table,"foo",sizeof("foo"),&arr,sizeof(pval),NULL);

This code declares a new array, named $foo, in the active symbol table. This array is empty.

Here's how to add new entries to it:

Example 0-6. Adding entries to a new array

pval entry;
entry.type = IS_LONG;
entry.value.lval = 5;
  
/* defines $foo["bar"] = 5 */
hash_update(arr.value.ht,"bar",sizeof("bar"),&entry,sizeof(pval),NULL); 
/* defines $foo[7] = 5 */
hash_index_update(arr.value.ht,7,&entry,sizeof(pval),NULL); 
/* defines the next free place in $foo[],
 * $foo[8], to be 5 (works like php2)
 */
hash_next_index_insert(arr.value.ht,&entry,sizeof(pval),NULL); 

If you'd like to modify a value that you inserted to a hash, you must first retrieve it from the hash. To prevent that overhead, you can supply a pval ** to the hash add function, and it'll be updated with the pval * address of the inserted element inside the hash. If that value is NULL (like in all of the above examples) - that parameter is ignored.

hash_next_index_insert() uses more or less the same logic as "$foo[] = bar;" in PHP 2.0.

If you are building an array to return from a function, you can initialize the array just like above by doing:

if (array_init(return_value) == FAILURE) { failed...; }

...and then adding values with the helper functions:

add_next_index_long(return_value,long_value);
add_next_index_double(return_value,double_value);
add_next_index_string(return_value,estrdup(string_value));

Of course, if the adding isn't done right after the array initialization, you'd probably have to look for the array first:

pval *arr;
if (hash_find(active_symbol_table,"foo",sizeof("foo"),(void **)&arr)==FAILURE) { can't find... }
else { use arr->value.ht... }

Note that hash_find receives a pointer to a pval pointer, and not a pval pointer.

Just about any hash function returns SUCCESS or FAILURE (except for hash_exists(), which returns a boolean truth value).


Returning simple values

ÇÔ¼ö¿¡¼­ ½±°Ô °ªÀ» ¹ÝȯÇϱâ À§ÇØ ´ÙÀ½°ú °°Àº ¸î °³ÀÇ ¸ÅÅ©·Î°¡ ÀÖ´Ù. :

¸ðµç RETURN_* ¸ÅÅ©·ÎµéÀº return°ªÀ» ¼³Á¤Çϰí, ÇØ´ç ÇÔ¼ö·ÎºÎÅÍ º¹±ÍÇÑ´Ù. :

¸ðµç RETVAL_* ¸ÅÅ©·ÎµéÀº return°ªÀ» ¼³Á¤ÇÏÁö¸¸, ÇØ´ç ÇÔ¼ö·ÎºÎÅÍ º¹±ÍÇÏÁö´Â ¾Ê´Â´Ù. :

The string macros above will all estrdup() the passed 's' argument, so you can safely free the argument after calling the macro, or alternatively use statically allocated memory.

If your function returns boolean success/error responses, always use RETURN_TRUE and RETURN_FALSE respectively.


Returning complex values

ÇÔ¼ö´Â object³ª array°°Àº complex dataµµ ¹ÝȯÇÒ ¼ö ÀÖ´Ù.

Returning an object:

The functions used to populate an object are:

Returning an array:

The functions used to populate an array are:


Using the resource list

PHP 3.0Àº ¿©·¯ ÀÚ¿øÀÇ °¡Áö ÇüŸ¦ ´Ù·ç´Â Ç¥ÁØÀûÀÎ ¹æ¹ýÀ» °¡Áö°í ÀÖ´Ù. À̰ÍÀº PHP 2.0ÀÇ ¸ðµç Áö¿ªÀûÀÎ linked list¸¦ ´ëüÇÑ´Ù.

Available functions:

Typically, these functions are used for SQL drivers but they can be used for anything else; for instance, maintaining file descriptors.

Typical list code would look like this:

Example 0-7. Adding a new resource

RESOURCE *resource;
/* ...allocate memory for resource and acquire resource... */
/* add a new resource to the list */
return_value->value.lval = php3_list_insert((void *) resource, LE_RESOURCE_TYPE);
return_value->type = IS_LONG;

Example 0-8. Using an existing resource

pval *resource_id;
RESOURCE *resource;
int type;
convert_to_long(resource_id);
resource = php3_list_find(resource_id->value.lval, &type);
if (type != LE_RESOURCE_TYPE) {
        php3_error(E_WARNING,"resource index %d has the wrong type",resource_id->value.lval);
        RETURN_FALSE;
}
/* ...use resource... */
 

Example 0-9. Deleting an existing resource

pval *resource_id;
RESOURCE *resource;
int type;
convert_to_long(resource_id);
php3_list_delete(resource_id->value.lval);
 

The resource types should be registered in php3_list.h, in enum list_entry_type. In addition, one should add shutdown code for any new resource type defined, in list.c's list_entry_destructor() (even if you don't have anything to do on shutdown, you must add an empty case).


Using the persistent resource table

PHP 3.0Àº ¿µ±¸ÀûÀÎ ÀÚ¿ø(persistent resources; i.e., resources that are kept in between hits)À» ÀúÀåÇϴ ǥÁØÀûÀÎ ¹æ¹ýÀ» °¡Áö°í ÀÖ´Ù. ÀÌ ¹æ¹ýÀº MySQL ¸ðµâ¿¡¼­ óÀ½»ç¿ëµÇ¾ú°í, mSQLµµ À̰ÍÀ» µû¸£°í ÀÖ´Ù. µû¶ó¼­ persistent resource¸¦ ¾î¶»°Ô »ç¿ëÇϴ°¡¿¡ ´ëÇØ ¾Ë°í ½Í´Ù¸é ¿ì¼± mysql.c¸¦ Àоµµ·ÏÇÏÀÚ. ÁÖÀÇÇØ¼­ º¼ ÇÔ¼öµéÀº ´ÙÀº°ú °°´Ù. :

php3_mysql_do_connect

php3_mysql_connect()

php3_mysql_pconnect()

persistence ¸ðµâÀÇ ÀϹÝÀûÀÎ idea´Â ´ÙÀ½°ú °°´Ù. :

If you read mysql.c, you'll notice that except for the more complex connect function, nothing in the rest of the module has to be changed.

The very same interface exists for the regular resource list and the persistent resource list, only 'list' is replaced with 'plist':

However, it's more than likely that these functions would prove to be useless for you when trying to implement a persistent module. Typically, one would want to use the fact that the persistent resource list is really a hash table. For instance, in the MySQL/mSQL modules, when there's a pconnect() call (persistent connect), the function builds a string out of the host/user/passwd that were passed to the function, and hashes the SQL link with this string as a key. The next time someone calls a pconnect() with the same host/user/passwd, the same key would be generated, and the function would find the SQL link in the persistent list.

Until further documented, you should look at mysql.c or msql.c to see how one should use the plist's hash table abilities.

One important thing to note: resources going into the persistent resource list must *NOT* be allocated with PHP's memory manager, i.e., they should NOT be created with emalloc(), estrdup(), etc. Rather, one should use the regular malloc(), strdup(), etc. The reason for this is simple - at the end of the request (end of the hit), every memory chunk that was allocated using PHP's memory manager is deleted. Since the persistent list isn't supposed to be erased at the end of a request, one mustn't use PHP's memory manager for allocating resources that go to it.

When you register a resource that's going to be in the persistent list, you should add destructors to it both in the non-persistent list and in the persistent list. The destructor in the non-persistent list destructor shouldn't do anything. The one in the persistent list destructor should properly free any resources obtained by that type (e.g. memory, SQL links, etc). Just like with the non-persistent resources, you *MUST* add destructors for every resource, even it requires no destructotion and the destructor would be empty. Remember, since emalloc() and friends aren't to be used in conjunction with the persistent list, you mustn't use efree() here either.


Adding runtime configuration directives

¸¹Àº PHPÀÇ ±â´É(feature)µéÀÌ ½ÇÇàÁß¿¡ ¼³Á¤ °¡´ÉÇÏ´Ù. ÀÌ ¼³Á¤ Áö½ÃÀÚ(configuration directives)´Â php3.ini¿¡ ¼³Á¤µÇ°Å³ª, Apache ¸ðµâÀÇ °æ¿ì .conf ÆÄÀÏ¿¡ ¼³Á¤°¡´ÉÇϵµ·Ï µÇ¾î ÀÖ´Ù. Apache .conf ÆÄÀÏ¿¡ ¼³Á¤ÇÏ´Â °ÍÀÇ ÀåÁ¡Àº µð·ºÅ丮º°·Î ¼³Á¤À» ´Ù¸£°Ô ÇÒ ¼ö ÀÖ´Ù´Â Á¡ÀÌ´Ù. À̰ÍÀº ¿¹¸¦µé¾î ¾î¶² µð·ºÅ丮°¡ ´Ù¸¥ µð·ºÅ丮¸¦ °¡Áö°í À־, ÇØ´çÇÏ´Â ÇÑ µð·ºÅ丮¿¡¸¸ safemodeexecdir ¼³Á¤À» ÇÒ ¼ö ÀÖ´Ù´Â °ÍÀÌ´Ù. ÀÌ °³º° ¼³Á¤ ±â´ÉÀº ¼­¹ö°¡ multiple virtual hosts¸¦ Áö¿øÇÒ ¶§ ¹«Ã´ À¯¿ëÇÏ´Ù.

The steps required to add a new directive:


Calling User Functions

³»ºÎ ÇÔ¼ö(internal function)¿¡¼­ »ç¿ëÀÚ ÇÔ¼ö¸¦ ºÎ¸£·Á¸é, call_user_function() ÇÔ¼ö¸¦ »ç¿ëÇÏ¿©¾ß ÇÑ´Ù.

call_user_function() returns SUCCESS on success, and FAILURE in case the function cannot be found. You should check that return value! If it returns SUCCESS, you are responsible for destroying the retval pval yourself (or return it as the return value of your function). If it returns FAILURE, the value of retval is undefined, and you mustn't touch it.

All internal functions that call user functions must be reentrant. Among other things, this means they must not use globals or static variables.

call_user_function() takes six arguments:


HashTable *function_table

This is the hash table in which the function is to be looked up.


pval *object

This is a pointer to an object on which the function is invoked. This should be NULL if a global function is called. If it's not NULL (i.e. it points to an object), the function_table argument is ignored, and instead taken from the object's hash. The object *may* be modified by the function that is invoked on it (that function will have access to it via $this). If for some reason you don't want that to happen, send a copy of the object instead.


pval *function_name

The name of the function to call. Must be a pval of type IS_STRING with function_name.str.val and function_name.str.len set to the appropriate values. The function_name is modified by call_user_function() - it's converted to lowercase. If you need to preserve the case, send a copy of the function name instead.


pval *retval

A pointer to a pval structure, into which the return value of the invoked function is saved. The structure must be previously allocated - call_user_function() does NOT allocate it by itself.


int param_count

The number of parameters being passed to the function.


pval *params[]

An array of pointers to values that will be passed as arguments to the function, the first argument being in offset 0, the second in offset 1, etc. The array is an array of pointers to pval's; The pointers are sent as-is to the function, which means if the function modifies its arguments, the original values are changed (passing by reference). If you don't want that behavior, pass a copy instead.


Reporting Errors

³»ºÎ ÇÔ¼ö¿¡¼­ ¿¡·¯¸¦ reportÇÒ ¶§´Â php3_error()ÇÔ¼ö¸¦ »ç¿ëÇÏ´Â °ÍÀÌ ÁÁ´Ù. ÀÌ ÇÔ¼ö´Â ÃÖ¼Ò µÎ°³ÀÇ Àμö¸¦ °¡Áö°í È£ÃâµÈ´Ù. ù¹øÂ°´Â ¿¡·¯ÀÇ levelÀ̰í, ´Ù¸¥ Çϳª´Â ¿¡·¯ ¸Þ¼¼Áö¸¦ À§ÇÑ format string( printf()¿¡¼­ »ç¿ëµÇ´Â °Í°ú °°Àº ÇüÅÂ) ÀÌ´Ù. ±×¸®°í ±× ³ª¸ÓÁö´Â ÁÖ¾îÁø format stringÀÇ parameter°¡ µÈ´Ù. ¿¡·¯ levelÀº ´ÙÀ½°ú °°´Ù. :


E_NOTICE

Notice´Â ±âº»ÀûÀ¸·Î´Â Ãâ·ÂµÇÁö ¾Ê´Â´Ù. À̰ÍÀº ½ºÅ©¸³Æ®°¡ ¹º°¡ ¿¡·¯¸¦ °¨ÁöÇßÁö¸¸, ±×°ÍÀÌ Á¤»óÀûÀÎ »óȲ¿¡¼­ ¹ß»ýÇÏ´Â °ÍÀ̶ó´Â ÀǹÌÀÌ´Ù. ¿¹¸¦µé¾î ¼³Á¤µÇÁö ¾ÊÀº º¯¼ö¸¦ »ç¿ëÇÏ·Á Ç߰ųª, Á¸ÀçÇÏÁö ¾Ê´Â ÆÄÀÏ¿¡ stat() ÇÔ¼ö¸¦ È£ÃâÇÏ´Â °Í µîÀÌ´Ù.


E_WARNING

WarningÀº ±âº»ÀûÀ¸·Î Ãâ·ÂµÈ´Ù. ±×·¯³ª, ½ºÅ©¸³Æ®ÀÇ ½ÇÇàÀ» ¸ØÃßÁö´Â ¾Ê´Â´Ù. À̰ÍÀº È£ÃâÀÌ ¿Ï·áµÇ±â Àü¿¡ ½ºÅ©¸³Æ®¿¡ ÀÇÇØ ÀâÇôÁ®¾ß ÇÏ´Â ¹®Á¦¸¦ °¡¸®Å²´Ù. ¿¹¸¦µé¾î À߸øµÈ regular expressionÀ¸·Î ereg()¸¦ È£ÃâÇÏ´Â °Í µîÀÌ´Ù.


E_ERROR

Errorµµ ±âº»ÀûÀ¸·Î Ãâ·ÂµÈ´Ù. ±×¸®°í, ÇÔ¼öÀÇ ½ÇÇàÀÌ ¿Ï·áµÈ Á÷ÈÄ, ½ºÅ©¸³Æ®ÀÇ ½ÇÇàÀ» ¸ØÃá´Ù. À̰ÍÀº memory allocation ¹®Á¦°°Àº º¹±¸°¡ ºÒ°¡´ÉÇÑ ¿¡·¯¸¦ ÀǹÌÇÑ´Ù.


E_PARSE

Parse error´Â ¿ÀÁ÷ Parser¸¸ÀÌ »ý¼º°¡´ÉÇÏ´Ù. code°¡ listµÈ´Ù.


E_CORE_ERROR

PHPÀÇ core¿¡ÀÇÇØ »ý¼ºµÈ´Ù´Â Á¡À» Á¦¿ÜÇϰí´Â E_ERROR¿Í µ¿ÀÏÇÏ´Ù. ÀÏ¹Ý ÇÔ¼ö·Î´Â ÀÌ ÇüÅÂÀÇ ¿¡·¯¸¦ ¸¸µéÁö ¸øÇÑ´Ù.


E_CORE_WARNING

PHPÀÇ core¿¡ÀÇÇØ »ý¼ºµÈ´Ù´Â Á¡À» Á¦¿ÜÇϰí´Â E_WARNING¿Í µ¿ÀÏÇÏ´Ù. ÀÏ¹Ý ÇÔ¼ö·Î´Â ÀÌ ÇüÅÂÀÇ ¿¡·¯¸¦ ¸¸µéÁö ¸øÇÑ´Ù.


Appendix C. The PHP Debugger


Using the Debugger

PHPÀÇ ³»Àå µð¹ö°Å´Â ÆÄ¾ÇÇϱâ Èûµç ¹ö±×¸¦ ã¾Æ³»´Âµ¥ ¸Å¿ì À¯¿ëÇÑ µµ±¸ÀÌ´Ù. µð¹ö°Å´Â PHP°¡ ½ÃÀÛµÉ ¶§¸¶´Ù TCP Æ÷Æ®¿¡ Á¢¼ÓÇÏ¿© µ¿ÀÛÇÑ´Ù. ¿ä±¸¿¡ ´ëÇÑ ¸ðµç ¿¡·¯ ¸Þ¼¼Áö°¡ ÀÌ Á¡¼ÓÀ» ÅëÇØ Àü´ÞµÈ´Ù. This information is intended for "debugging server" that can run inside an IDE or programmable editor (such as Emacs).

debugger ¼³Á¤ ¹æ¹ý:

ÀÌÁ¦, ¸ðµç warning°ú notice µîÀÌ listener socket¿¡ Ç¥½ÃµÉ °ÍÀÌ´Ù. ¸¸¾à ¿©·¯ºÐÀÌ error_reporting()¸¦ »ç¿ëÇØ¼­ reportÇÏÁö ¸øÇϵµ·Ï ÇØµµ ÀÌ ·¹Æ÷Æ®´Â µ¿ÀÛÇÑ´Ù.


Debugger Protocol

debugger protocolÀº ¶óÀÎ ´ÜÀ§ÀÌ´Ù. °¢ ¶óÀÎÀº typeÀ» °¡Áö°í ÀÖ°í, ¿©·¯¶óÀÎÀÌ ÇϳªÀÇ ¸Þ¼¼Áö¸¦ ±¸¼ºÇÑ´Ù. °¢ ¸Þ¼¼Áö´Â start type À¸·Î ½ÃÀÛÇϰí, end typeÀ¸·Î ³¡³­´Ù. PHP´Â µ¿½Ã¿¡ ¿©·¯ ´Ù¸¥ ¸Þ¼¼ÁöÀÇ ¶óÀÎÀ» º¸³¾ ¼öµµ ÀÖ´Ù.

ÇÑ ÁÙÀº ´ÙÀ½°ú °°Àº formatÀ¸·Î µÇ¾î ÀÖ´Ù.:

ÇÑ ÁÙÀº ´ÙÀ½°ú °°Àº formatÀ¸·Î µÇ¾î ÀÖ´Ù.:

date time host(pidtypemessage-data

date
Date in ISO 8601 format (yyyy-mm-dd)
time
Time including microseconds: hh:mm:uuuuuu
host
script error °¡ »ý±ä DNS name À̳ª IP address
pid
ÀÌ ¿¡·¯¸¦ ¸¸µç PHP script processÀÇ hostÀÇ PID (process id)
type
¶óÀÎÀÇ type. Tells the receiving program about what it should treat the following data as:

Table C-1. Debugger Line Types

Name

Meaning

start

Tells the receiving program that a debugger message starts here. The contents of data will be the type of error message, listed below.

message

The PHP error message.

location

File name and line number where the error occured. The first location line will always contain the top-level location. data will contain file:line. There will always be a location line after message and after every function.

frames

Number of frames in the following stack dump. If there are four frames, expect information about four levels of called functions. If no "frames" line is given, the depth should be assumed to be 0 (the error occured at top-level).

function

Name of function where the error occured. Will be repeated once for every level in the function call stack.

end

Tells the receiving program that a debugger message ends here.

data
Line data.

Table C-2. Debugger Error Types

Debugger

PHP Internal

warning

E_WARNING

error

E_ERROR

parse

E_PARSE

notice

E_NOTICE

core-error

E_CORE_ERROR

core-warning

E_CORE_WARNING

unknown

(any other)

 

Example C-1. Example Debugger Message

1998-04-05 23:27:400966 lucifer.guardian.no(20481) start: notice
1998-04-05 23:27:400966 lucifer.guardian.no(20481) message: Uninitialized variable
1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: (null):7
1998-04-05 23:27:400966 lucifer.guardian.no(20481) frames: 1
1998-04-05 23:27:400966 lucifer.guardian.no(20481) function: display
1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: /home/ssb/public_html/test.php3:10
1998-04-05 23:27:400966 lucifer.guardian.no(20481) end: notice

 

Notes

[1]

Be careful here. The value part must be malloc'ed manually because the memory management code will try to free this pointer later. Do not pass statically allocated memory into a SET_VAR_STRING.

[End Of Page]