SPECIFIC

_Alphabetically:
* database-management#ql:php'doing.database_management#,
* suggesting,

lcpPhp'array'code

name::
* McsEngl.lcpPhp'array'code@cptIt,
* McsEngl.lcpPhp'code.ARRAY@cptIt,
* McsEngl.lcpPhp'data.Array-datatype@cptIt,
* McsEngl.lcpPhp'array@cptIt,

_GENERIC:
* primitive-datatype#ql:php'primitive_data_type#

_DESCRIPTION:
An array is a datatype that can hold multiple instances of other datatypes. In PHP there are two types of arrays, numerically indexed and associative. The elements of a numerically indexed array are referenced with a numerical index enclosed in [] brackets. For example, $my_array[1] would be the second element in $my_array. Associative arrays are not limited to using numbers for indexing. Instead "keys" in the form of strings are used to reference elements. This can be useful for pairing of data. For example, the names of husbands could be mapped to the names of their wives like this: $couples["Jonathan"] = "Mindy";
Arrays can also be multidimensional. To reference an element in a two-dimensional array, double indexes are used: $my_array[1][2].
[http://www.devguru.com/technologies/php/5896.asp]
===
An array in PHP is actually an ordered map. A map is a type that associates values to keys. This type is optimized for several different uses; it can be treated as an
- array,
- list (vector),
- hash table (an implementation of a map),
- dictionary,
- collection,
- stack,
- queue, and
- probably more.
As array values can be other arrays, trees and multidimensional arrays are also possible.
[http://www.php.net/manual/en/language.types.array.php]
===
A variable is a storage area holding a number or text. The problem is, a variable will hold only one value.
An array is a special variable, which can store multiple values in one single variable.
[http://www.w3schools.com/php/php_arrays.asp]

lcpPhp'array'Creation

name::
* McsEngl.lcpPhp'array'Creation@cptIt,

There are two methods to create a numeric array.

1. In the following example the index are automatically assigned (the index starts at 0):
$cars=array("Saab","Volvo","BMW","Toyota");

2. In the following example we assign the index manually:
$cars[0]="Saab";
$cars[1]="Volvo";
$cars[2]="BMW";
$cars[3]="Toyota";
[http://www.w3schools.com/php/php_arrays.asp]

Associative Arrays

An associative array, each ID key is associated with a value.

When storing data about specific named values, a numerical array is not always the best way to do it.

With associative arrays we can use the values as keys and assign values to them.

Example 1
In this example we use an array to assign ages to the different persons:
$ages = array("Peter"=>32, "Quagmire"=>30, "Joe"=>34);

Example 2
This example is the same as example 1, but shows a different way of creating the array:
$ages['Peter'] = "32";
$ages['Quagmire'] = "30";
$ages['Joe'] = "34";
[http://www.w3schools.com/php/php_arrays.asp]

lcpPhp'array'Resource

name::
* McsEngl.lcpPhp'array'Resource@cptIt,

Complete reference:
* http://www.w3schools.com/php/php_ref_array.asp,

SPECIFIC

name::
* McsEngl.lcpPhp'array.SPECIFIC@cptIt,

_SPECIFIC:
In PHP, there are three kind of arrays:
Numeric array - An array with a numeric index
Associative array - An array where each ID key is associated with a value
Multidimensional array - An array containing one or more arrays
[http://www.w3schools.com/php/php_arrays.asp]

lcpPhp'array.ASSOCIATIVE

name::
* McsEngl.lcpPhp'array.ASSOCIATIVE@cptIt,
* McsEngl.lcpPhp'associative-array@cptIt,
* McsEngl.lcpPhp'data.Key-value@cptIt,
* McsEngl.lcpPhp'key-value-data@cptIt,
* McsEngl.lcpPhp'map@cptIt,

_CODE.PHP:
$ages = array("Peter"=>32, "Quagmire"=>30, "Joe"=>34);
var_dump($ages);
//array(3) { ["Peter"]=> int(32) ["Quagmire"]=> int(30) ["Joe"]=> int(34) }

_DESCRIPTION:
Associative Arrays
An associative array, each ID key is associated with a value.

When storing data about specific named values, a numerical array is not always the best way to do it.

With associative arrays we can use the values as keys and assign values to them.

Example 1
In this example we use an array to assign ages to the different persons:
$ages = array("Peter"=>32, "Quagmire"=>30, "Joe"=>34);

Example 2
This example is the same as example 1, but shows a different way of creating the array:
$ages['Peter'] = "32";
$ages['Quagmire'] = "30";
$ages['Joe'] = "34";
[http://www.w3schools.com/php/php_arrays.asp]

lcpPhp'array.NUMERIC

name::
* McsEngl.lcpPhp'array.NUMERIC@cptIt,

_DESCRIPTION:
There are two methods to create a numeric array.

1. In the following example the index are automatically assigned (the index starts at 0):
$cars=array("Saab","Volvo","BMW","Toyota");

2. In the following example we assign the index manually:
$cars[0]="Saab";
$cars[1]="Volvo";
$cars[2]="BMW";
$cars[3]="Toyota";
[http://www.w3schools.com/php/php_arrays.asp]

_CODE.PHP:
$cars=array("Volvo","BMW","Toyota");
var_dump($cars);
//array(3) { [0]=> string(5) "Volvo" [1]=> string(3) "BMW" [2]=> string(6) "Toyota" }

lcpPhp'array.Example

name::
* McsEngl.lcpPhp'array.Example@cptIt,
* McsEngl.lcpPhp'ex.Array@cptIt,

_CODE.PHP:
_CODE.PHP:
$ages = array("Peter"=>32, "Quagmire"=>30, "Joe"=>34);
var_dump($ages);
//array(3) { ["Peter"]=> int(32) ["Quagmire"]=> int(30) ["Joe"]=> int(34) }
===
$cars=array("Volvo","BMW","Toyota");
var_dump($cars);
//array(3) { [0]=> string(5) "Volvo" [1]=> string(3) "BMW" [2]=> string(6) "Toyota" }
===
<?php
$arr = array("foo" => "bar", 12 => true);

echo $arr["foo"]; // bar
echo $arr[12]; // 1
?>

===
<?php
$arr = array("somearray" => array(6 => 5, 13 => 9, "a" => 42));

echo $arr["somearray"][6]; // 5
echo $arr["somearray"][13]; // 9
echo $arr["somearray"]["a"]; // 42
?>

===
// This:
$a = array( 'color' => 'red',
'taste' => 'sweet',
'shape' => 'round',
'name' => 'apple',
4 // key will be 0
);

$b = array('a', 'b', 'c');

// . . .is completely equivalent with this:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name'] = 'apple';
$a[] = 4; // key will be 0

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// After the above code is executed, $a will be the array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4), and $b will be the array
// array(0 => 'a', 1 => 'b', 2 => 'c'), or simply array('a', 'b', 'c').

lcpPhp'array.LIST

name::
* McsEngl.lcpPhp'array.LIST@cptIt,
* McsEngl.lcpPhp'data.LIST@cptIt,
* McsEngl.lcpPhp'list-datatype@cptIt,

_DESCRIPTION:
Arrays can contain elements of any type that PHP can handle, including resources, objects, and even other arrays.

lcpPhp'constant'code

name::
* McsEngl.lcpPhp'constant'code@cptIt,
* McsEngl.lcpPhp'code.CONSTANT@cptIt,
* McsEngl.lcpPhp'constant@cptIt,
* McsEngl.lcpPhp'Constant-code@cptIt,

_GENERIC:
* container-code#ql:php'container_code#,
* codetype#ql:php'codetype#

_DESCRIPTION:
A constant is an identifier (name) for a simple value. As the name suggests, that value cannot change during the execution of the script (except for magic constants, which aren't actually constants). A constant is case-sensitive by default. By convention, constant identifiers are always uppercase.
The name of a constant follows the same rules as any label in PHP. A valid constant name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thusly: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
[http://www.php.net/manual/en/language.constants.php]
===
Only scalar data (boolean, integer, float and string) can be contained in constants. It is possible to define constants as a resource, but it should be avoided, as it can cause unexpected results.
[http://www.php.net/manual/en/language.constants.syntax.php]

lcpPhp'constant'Creating

name::
* McsEngl.lcpPhp'constant'Creating@cptIt,

You can define a constant by using the define()-function or by using the const keyword outside a class definition as of PHP 5.3.0. Once a constant is defined, it can never be changed or undefined.
[http://www.php.net/manual/en/language.constants.syntax.php]

lcpPhp'constant'Function

name::
* McsEngl.lcpPhp'constant'Function@cptIt,

_SPECIFIC:
* define,

lcpPhp'constant'name

name::
* McsEngl.lcpPhp'constant'name@cptIt,

Unlike with variables, you should not prepend a constant with a $.
[http://www.php.net/manual/en/language.constants.syntax.php]

lcpPhp'constant'scope

name::
* McsEngl.lcpPhp'constant'scope@cptIt,

Like superglobals, the scope of a constant is global. You can access constants anywhere in your script without regard to scope. For more information on scope, read the manual section on variable scope.
[http://www.php.net/manual/en/language.constants.php]

SPECIFIC

lcpPhp'constant.EXAMPLE

name::
* McsEngl.lcpPhp'constant.EXAMPLE@cptIt,

_CODE.PHP:
const STRCOND_PRE = 0;

define( 'SMW_SQL2_SMWIW_OUTDATED', ':smw' ); // virtual "interwiki prefix" for old-style special SMW objects (no longer used)

lcpPhp'constant.MAGIC

name::
* McsEngl.lcpPhp'constant.MAGIC@cptIt,

Magic constants

PHP provides a large number of predefined constants to any script which it runs. Many of these constants, however, are created by various extensions, and will only be present when those extensions are available, either via dynamic loading or because they have been compiled in.

There are seven magical constants that change depending on where they are used. For example, the value of __LINE__ depends on the line that it's used on in your script. These special constants are case-insensitive and are as follows:

A few "magical" PHP constants
Name  Description
* lcpPhp'LINE_magic, php__LINE__   The current line number of the file.
* lcpPhp'FILE_magic, php__FILE__   The full path and filename of the file. If used inside an include, the name of the included file is returned. Since PHP 4.0.2, __FILE__ always contains an absolute path with symlinks resolved whereas in older versions it contained relative path under some circumstances.
* lcpPhp'DIR_magic, php__DIR__   The directory of the file. If used inside an include, the directory of the included file is returned. This is equivalent to dirname(__FILE__). This directory name does not have a trailing slash unless it is the root directory. (Added in PHP 5.3.0.)
* lcpPhp'FUNCTION_magic, php__FUNCTION__   The function name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the function name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
* lcpPhp'CLASS_magic, php__CLASS__   The class name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the class name as it was declared (case-sensitive). In PHP 4 its value is always lowercased. The class name includes the namespace it was declared in (e.g. Foo\Bar).
* lcpPhp'METHOD_magic, php__METHOD__   The class method name. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).
* lcpPhp'NAMESPACE_magic, php__NAMESPACE__   The name of the current namespace (case-sensitive). This constant is defined in compile-time (Added in PHP 5.3.0).
[http://us3.php.net/manual/en/language.constants.predefined.php]

lcpPhp'constant.PREDEFINED

name::
* McsEngl.lcpPhp'constant.PREDEFINED@cptIt,

_DESCRIPTION:
PHP provides a large number of predefined constants to any script which it runs. Many of these constants, however, are created by various extensions, and will only be present when those extensions are available, either via dynamic loading or because they have been compiled in.
There are seven magical constants that change depending on where they are used. For example, the value of __LINE__ depends on the line that it's used on in your script.
[http://www.php.net/manual/en/language.constants.predefined.php]
===
Predefined Constants ¶

The constants below are defined by this extension, and will only be available when the extension has either been compiled into PHP or dynamically loaded at runtime.

DIRECTORY_SEPARATOR (string)
PATH_SEPARATOR (string)
Available since PHP 4.3.0. Semicolon on Windows, colon otherwise.
SCANDIR_SORT_ASCENDING (integer)
Available since PHP 5.4.0.
SCANDIR_SORT_DESCENDING (integer)
Available since PHP 5.4.0.
SCANDIR_SORT_NONE (integer)
Available since PHP 5.4.0.
[http://php.net/manual/en/dir.constants.php]

_ADDRESS.WPG:
* http://www.php.net/manual/en/reserved.constants.php,

lcpPhp'class'code

name::
* McsEngl.lcpPhp'class'code@cptIt,
* McsEngl.lcpPhp'code.CLASS@cptIt,
* McsEngl.lcpPhp'class@cptIt,
* McsEngl.lcpPhp'Class-code@cptIt,

_GENERIC:
* container-code#ql:php'container_code#,
* codetype#ql:php'codetype#,
* unit-of-code#ql:php'unit_of_code#

_DEFINITION:
Class is CODE that holds data and functions.
[hmnSngo.2011-09-27]

_PART:
A class may contain its own constants, variables (called "properties"), and functions (called "methods").
[http://www.php.net/manual/en/language.oop5.basic.php]

lcpPhp'class'creating

name::
* McsEngl.lcpPhp'class'creating@cptIt,

A class is a collection of variables and functions working with these variables. Variables are defined by var and functions by function. A class is defined using the following syntax:

<?php
class Cart {
var $items; // Items in our shopping cart

// Add $num articles of $artnr to the cart

function add_item($artnr, $num) {
$this->items[$artnr] += $num;
}

// Take $num articles of $artnr out of the cart

function remove_item($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
return true;
} elseif ($this->items[$artnr] == $num) {
unset($this->items[$artnr]);
return true;
} else {
return false;
}
}
}
?>
[http://www.php.net/manual/en/keyword.class.php]

lcpPhp'class'Member

name::
* McsEngl.lcpPhp'class'Member@cptIt,

_Access:
$this->mTitle
$this->getId()'

_SPECIFIC:
* constant,
* method (function)
* property (variable)
===
* public,
* protected,
* private,

lcpPhp'class'meber-visibility

name::
* McsEngl.lcpPhp'class'meber-visibility@cptIt,

_Visibility
The visibility of a property or method can be defined by prefixing the declaration with the keywords public, protected or private. Class members declared public can be accessed everywhere. Members declared protected can be accessed only within the class itself and by inherited and parent classes. Members declared as private may only be accessed by the class that defines the member.
[http://www.php.net/manual/en/language.oop5.visibility.php]

lcpPhp'private_member (unique-class):
Members declared as private may only be accessed by the class that defines the member.
[http://www.php.net/manual/en/language.oop5.visibility.php]

lcpPhp'protected_member (hierarchy):
Members declared protected can be accessed only within the class itself and by inherited and parent classes.
[http://www.php.net/manual/en/language.oop5.visibility.php]

lcpPhp'public_member (everywhere):
Class members declared public can be accessed everywhere.
[http://www.php.net/manual/en/language.oop5.visibility.php]

lcpPhp'class'Method

name::
* McsEngl.lcpPhp'class'Method@cptIt,
* McsEngl.lcpPhp'member-function@cptIt,
* McsEngl.lcpPhp'method@cptIt,

_DESCRIPTION:
A class may contain its own constants, variables (called "properties"), and functions (called "methods").
[http://www.php.net/manual/en/language.oop5.basic.php]

_SPECIFIC:
* private,
* protected,
* public,
* static protected,
* static public,

lcpPhp'class'name

name::
* McsEngl.lcpPhp'class'name@cptIt,

_DESCRIPTION:
The class name can be any valid label which is a not a PHP-reserved-word#ql:php'keyword#. A valid class name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.
[http://www.php.net/manual/en/language.oop5.basic.php]
===
::class ¶

Since PHP 5.5, the class keyword is also used for class name resolution. You can get a string containing the fully qualified name of the ClassName class by using ClassName::class. This is particularly useful with namespaced classes.

Example#7 Class name resolution

<?php
namespace NS {
class ClassName {
}

echo ClassName::class;
}
?>
The above example will output:

NS\ClassName
[http://www.php.net/manual/en/language.oop5.basic.php]

lcpPhp'class'Parent-keyword

name::
* McsEngl.lcpPhp'class'Parent-keyword@cptIt,
* McsEngl.lcpPhp'parent-keyword@cptIt,
* McsEngl.lcpPhp'self-keyword@cptIt,

_DESCRIPTION:
Two special keywords self and parent are used to access properties or methods from inside the class definition.

Example#2 :: from inside the class definition
<?php
class OtherClass extends MyClass
{
public static $my_static = 'static var';

public static function doubleColon() {
echo parent::CONST_VALUE . "\n";
echo self::$my_static . "\n";
}
}

$classname = 'OtherClass';
echo $classname::doubleColon(); // As of PHP 5.3.0

OtherClass::doubleColon();
?>
[http://www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php]

lcpPhp'class'property

name::
* McsEngl.lcpPhp'class'property@cptIt,
* McsEngl.lcpPhp'attribute-of-class@cptIt,
* McsEngl.lcpPhp'class'variable@cptIt,
* McsEngl.lcpPhp'class'Variable-member@cptIt,
* McsEngl.lcpPhp'property-of-class@cptIt,

_DESCRIPTION:
A class may contain its own constants, variables (called "properties"), and functions (called "methods").
[http://www.php.net/manual/en/language.oop5.basic.php]

_Access:
Within class methods the properties, constants, and methods may be accessed by using the form $this->property (where property is the name of the property) unless the access is to a static property within the context of a static class method, in which case it is accessed using the form self::$property. See Static Keyword for more information.

The pseudo-variable $this is available inside any class method when that method is called from within an object context. $this is a reference to the calling object (usually the object to which the method belongs, but possibly another object, if the method is called statically from the context of a secondary object).
[http://www.php.net/manual/en/language.oop5.properties.php]

_SPECIFIC:
* private,
* protected,
* public,
* static

lcpPhp'class'Resource

name::
* McsEngl.lcpPhp'class'Resource@cptIt,

_SPECIFIC:
* http://net.tutsplus.com/tutorials/php/object-oriented-php-for-beginners//

lcpPhp'class'trait

name::
* McsEngl.lcpPhp'class'trait@cptIt,
* McsEngl.lcpPhp'code.TRAIT@cptIt,
* McsEngl.lcpPhp'trait@cptIt,

_GENERIC:
* code-unit#ql:php'unit_of_code#

_DESCTIPTION:
As of PHP 5.4.0, PHP implements a method of code reuse called Traits.

Traits is a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies. The semantics of the combination of Traits and classes is defined in a way which reduces complexity, and avoids the typical problems associated with multiple inheritance and Mixins.

A Trait is similar to a class, but only intended to group functionality in a fine-grained and consistent way. It is not possible to instantiate a Trait on its own. It is an addition to traditional inheritance and enables horizontal composition of behavior; that is, the application of class members without requiring inheritance.

Example#1 Trait example
<?php
trait ezcReflectionReturnInfo {
function getReturnType() { /*1*/ }
function getReturnDescription() { /*2*/ }
}

class ezcReflectionMethod extends ReflectionMethod {
use ezcReflectionReturnInfo;
/* ... */
}

class ezcReflectionFunction extends ReflectionFunction {
use ezcReflectionReturnInfo;
/* ... */
}
?>
[http://www.php.net/manual/en/language.oop5.traits.php]

SPECIFIC

name::
* McsEngl.lcpPhp'class.SPECIFIC@cptIt,

lcpPhp'class.ABSTRACT

name::
* McsEngl.lcpPhp'class.ABSTRACT@cptIt,

_DESCRIPTION:
PHP 5 introduces abstract classes and methods. Classes defined as abstract may not be instantiated, and any class that contains at least one abstract method must also be abstract. Methods defined as abstract simply declare the method's signature - they cannot define the implementation.
[http://www.php.net/manual/en/language.oop5.abstract.php]

lcpPhp'class.Base

name::
* McsEngl.lcpPhp'class.Base@cptIt,

Often you need classes with similar variables and functions to another existing class. In fact, it is good practice to define a generic class which can be used in all your projects and adapt this class for the needs of each of your specific projects. To facilitate this, classes can be extensions of other classes. The extended or derived class has all variables and functions of the base class (this is called 'inheritance' despite the fact that nobody died) and what you add in the extended definition. It is not possible to subtract from a class, that is, to undefine any existing functions or variables. An extended class is always dependent on a single base class, that is, multiple inheritance is not supported. Classes are extended using the keyword 'extends'.
[http://www.php.net/manual/en/keyword.extends.php]

lcpPhp'class.Example

name::
* McsEngl.lcpPhp'class.Example@cptIt,
* McsEngl.lcpPhp'ex.class@cptIt,

<?php
class SimpleClass
{
// property declaration
public $var = 'a default value';

// method declaration
public function displayVar() {
echo $this->var;
}
}
?>

class foo {
var $bar = 'I am bar-variable.';
}

lcpPhp'class.Extended

name::
* McsEngl.lcpPhp'class.Extended@cptIt,
* McsEngl.lcpPhp'derived-class@cptIt,

Often you need classes with similar variables and functions to another existing class. In fact, it is good practice to define a generic class which can be used in all your projects and adapt this class for the needs of each of your specific projects. To facilitate this, classes can be extensions of other classes. The extended or derived class has all variables and functions of the base class (this is called 'inheritance' despite the fact that nobody died) and what you add in the extended definition. It is not possible to subtract from a class, that is, to undefine any existing functions or variables. An extended class is always dependent on a single base class, that is, multiple inheritance is not supported. Classes are extended using the keyword 'extends'.
[http://www.php.net/manual/en/keyword.extends.php]

lcpPhp'class.FINAL

name::
* McsEngl.lcpPhp'class.FINAL@cptIt,
* McsEngl.lcpPhp'final-class@cptIt,

_DESCRIPTION:
PHP 5 introduces the final keyword, which prevents child classes from overriding a method by prefixing the definition with final. If the class itself is being defined final then it cannot be extended.
[http://www.php.net/manual/en/language.oop5.final.php]

lcpPhp'class.INHERITED

name::
* McsEngl.lcpPhp'class.INHERITED@cptIt,
* McsEngl.lcpPhp'child-class@cptIt,
* McsEngl.lcpPhp'subclass@cptIt,

_DESCRIPTION:
Object Inheritance ¶

Inheritance is a well-established programming principle, and PHP makes use of this principle in its object model. This principle will affect the way many classes and objects relate to one another.

For example, when you extend a class, the subclass inherits all of the public and protected methods from the parent class. Unless a class overrides those methods, they will retain their original functionality.

This is useful for defining and abstracting functionality, and permits the implementation of additional functionality in similar objects without the need to reimplement all of the shared functionality.

Note:
Unless autoloading is used, then classes must be defined before they are used. If a class extends another, then the parent class must be declared before the child class structure. This rule applies to classes that inherit other classes and interfaces.
[http://php.net/manual/en/language.oop5.inheritance.php]

lcpPhp'class.Object (instance)

name::
* McsEngl.lcpPhp'class.Object (instance)@cptIt,
* McsEngl.lcpPhp'archetype.OBJECT@cptIt,
* McsEngl.lcpPhp'class.instance@cptIt,
* McsEngl.lcpPhp'instance-class@cptIt,
* McsEngl.lcpPhp'object@cptIt,
* McsEngl.lcpPhp'object-model@cptIt,

_GENERIC:
* codetype#ql:php'codetype#

_DESCRIPTION:
PHP Objects
An object is a data type which stores data and information on how to process that data.
In PHP, an object must be explicitly declared.
First we must declare a class of object. For this, we use the class keyword. A class is a structure that can contain properties and methods.
[http://www.w3schools.com/Php/php_datatypes.asp]
===
To create an instance of a class, the new keyword must be used. An object will always be created unless the object has a constructor defined that throws an exception on error. Classes should be defined before instantiation (and in some cases this is a requirement).

If a string containing the name of a class is used with new, a new instance of that class will be created. If the class is in a namespace, its fully qualified name must be used when doing this.

Example#3 Creating an instance

<?php
$instance = new SimpleClass();

// This can also be done with a variable:
$className = 'Foo';
$instance = new $className(); // Foo()
?>
In the class context, it is possible to create a new object by new self and new parent.

When assigning an already created instance of a class to a new variable, the new variable will access the same instance as the object that was assigned. This behaviour is the same when passing instances to a function. A copy of an already created object can be made by cloning it.
[http://www.php.net/manual/en/language.oop5.basic.php#language.oop5.basic.new]
===
Starting with PHP 5, the object model was rewritten to allow for better performance and more features. This was a major change from PHP 4. PHP 5 has a full object model.

Among the features in PHP 5 are the inclusions of visibility, abstract and final classes and methods, additional magic methods, interfaces, cloning and typehinting.

PHP treats objects in the same way as references or handles, meaning that each variable contains an object reference rather than a copy of the entire object. See Objects and References
[http://www.php.net/manual/en/oop5.intro.php]

lcpPhp'compound'code

_CREATED: {2012-01-22}

name::
* McsEngl.lcpPhp'compound'code@cptIt,
* McsEngl.lcpPhp'code.CONTAINER@cptIt,
* McsEngl.lcpPhp'Container@cptIt,
* McsEngl.lcpPhp'Container-code@cptIt,
* McsEngl.lcpPhp'Group-of-code@cptIt,

_SPECIFIC:
* class#ql:php'class#,
* constant#ql:php'constant#,
* data-container#ql:lcpphp'container.data#,
* function#ql:php'function#,
* variable#ql:php'variable#

lcpPhp'container.Both

name::
* McsEngl.lcpPhp'container.Both@cptIt,
* McsEngl.lcpPhp'data-and-non-data-container@cptIt,
* McsEngl.lcpPhp'data-and-processing-container@cptIt,
* McsEngl.lcpPhp'mixed-container@cptIt,

_SPECIFIC:
* class#ql:php'class#,
* function#ql:php'function#,
* variable#ql:php'variable#

lcpPhp'container.Data

name::
* McsEngl.lcpPhp'container.Data@cptIt,

_SPECIFIC:
* constant#ql:php'constant#

lcpPhp'container.Processing

name::
* McsEngl.lcpPhp'container.Processing@cptIt,
* McsEngl.lcpPhp'dataNo-container@cptIt,
* McsEngl.lcpPhp'non-data-container@cptIt,

lcpPhp'compoundNo'code

_CREATED: {2012-01-22}

name::
* McsEngl.lcpPhp'compoundNo'code@cptIt,
* McsEngl.lcpPhp'code.CONTAINER.NO@cptIt,
* McsEngl.lcpPhp'ContainerNo-code@cptIt,

_SPECIFIC:
* literal,
* simple-command,

lcpPhp'function'code

name::
* McsEngl.lcpPhp'function'code@cptIt,
* McsEngl.lcpPhp'code.FUNCTION@cptIt,
* McsEngl.lcpPhp'function@cptIt,
* McsEngl.php'function@cptIt,

_GENERIC:
* container-code#ql:php'container_code#,
* codetype#ql:php'codetype#

_DESCRIPTION:
A function is just a name we give to a block of code that can be executed whenever we need it. This might not seem like that big of an idea, but believe me, when you understand and use functions you will be able to save a ton of time and write code that is much more readable!
[http://www.tizag.com/phpT/phpfunctions.php]
===
PHP has hundreds of base functions and thousands more via extensions. These functions are well documented on the PHP site; however, the built-in library has a wide variety of naming conventions and inconsistencies.[65] PHP currently has no functions for thread programming, although it does support multiprocess programming on POSIX systems.[66]
Additional functions can be defined by a developer:

function myFunction() { //declares a function, this is named myFunction
return 'John Doe'; //returns the value 'John Doe'
}

echo 'My name is ' . myFunction() . '!'; //outputs the text and the return variable of the myFunction, the function is also called
//the result of the output will be 'My name is John Doe!'
[http://en.wikipedia.org/wiki/Php]

lcpPhp'function'Argument

name::
* McsEngl.lcpPhp'function'Argument@cptIt,

_DESCRIPTION:
Information may be passed to functions via the argument list, which is a comma-delimited list of expressions.

PHP supports passing arguments by value (the default), passing by reference, and default argument values. Variable-length argument lists are also supported, see also the function references for func_num_args(), func_get_arg(), and func_get_args() for more information.
[http://www.php.net/manual/en/functions.arguments.php]

lcpPhp'function'Calling

name::
* McsEngl.lcpPhp'function'Calling@cptIt,

lcpPhp'function'Creating

name::
* McsEngl.lcpPhp'function'Creating@cptIt,
* McsEngl.lcpPhp'function-definition@cptIt,

<?php
function foo(&$var)
{
$var++;
}

$a=5;
foo($a);
// $a is 6 here
?>

lcpPhp'function'Name

name::
* McsEngl.lcpPhp'function'Name@cptIt,

Reference, returned from a function, i.e.:

<?php
function &bar()
{
$a = 5;
return $a;
}
foo(bar());
?>
[http://theserverpages.com/php/manual/en/language.references.pass.php]

lcpPhp'function'Resource

name::
* McsEngl.lcpPhp'function'Resource@cptIt,

_SPECIFIC:
* http://www.php.net/manual/en/funcref.php,

lcpPhp'function'Returning-value

name::
* McsEngl.lcpPhp'function'Returning-value@cptIt,

Returning values

Values are returned by using the optional return statement. Any type may be returned, including arrays and objects. This causes the function to end its execution immediately and pass control back to the line from which it was called. See return() for more information.

Note:

If the return() is omitted the value NULL will be returned.

Reference, returned from a function, i.e.:

<?php
function &bar()
{
$a = 5;
return $a;
}
foo(bar());
?>
[http://theserverpages.com/php/manual/en/language.references.pass.php]

SPECIFIC

Function Reference

Tip
See also Extension List/Categorization.

Affecting PHP's Behaviour
APC — Alternative PHP Cache
APD — Advanced PHP debugger
bcompiler — PHP bytecode Compiler
BLENC — Blenc - BLowfish ENCoder for PHP source scripts
Error Handling — Error Handling and Logging
htscanner — htaccess-like support for all SAPIs
inclued — Inclusion hierarchy viewer
Memtrack
OPcache
Output Control — Output Buffering Control
PHP Options/Info — PHP Options and Information
runkit
scream — Break the silence operator
Weakref — Weak References
WinCache — Windows Cache for PHP
Xhprof — Hierarchical Profiler
Audio Formats Manipulation
ID3 — ID3 Tags
KTaglib
oggvorbis — OGG/Vorbis
OpenAL — OpenAL Audio Bindings
Authentication Services
KADM5 — Kerberos V
Radius
Date and Time Related Extensions
Calendar
Date/Time — Date and Time
Command Line Specific Extensions
Ncurses — Ncurses Terminal Screen Control
Newt
Readline — GNU Readline
Compression and Archive Extensions
Bzip2
LZF
Phar
Rar — Rar Archiving
Zip
Zlib — Zlib Compression
Credit Card Processing
MCVE — MCVE (Monetra) Payment
SPPLUS — SPPLUS Payment System
Cryptography Extensions
Crack — Cracklib
Hash — HASH Message Digest Framework
Mcrypt
Mhash
OpenSSL
Password Hashing
Database Extensions
Abstraction Layers
Vendor Specific Database Extensions
File System Related Extensions
Direct IO
Directories
Fileinfo — File Information
Filesystem
Inotify
Mimetype
Proctitle
xattr
xdiff
Human Language and Character Encoding Support
Enchant — Enchant spelling library
FriBiDi
Gender — Determine gender of firstnames
Gettext
iconv
intl — Internationalization Functions
Multibyte String
Pspell
Recode — GNU Recode
Image Processing and Generation
Cairo
Exif — Exchangeable image information
GD — Image Processing and GD
Gmagick
ImageMagick — Image Processing (ImageMagick)
Mail Related Extensions
Cyrus — Cyrus IMAP administration
IMAP — IMAP, POP3 and NNTP
Mail
Mailparse
vpopmail
Mathematical Extensions
BC Math — BCMath Arbitrary Precision Mathematics
GMP — GNU Multiple Precision
Lapack
Math — Mathematical Functions
Statistics
Trader — Technical Analysis for Traders
Non-Text MIME Output
FDF — Forms Data Format
GnuPG — GNU Privacy Guard
haru — Haru PDF
Ming — Ming (flash)
PDF
PS — PostScript document creation
RPM Reader — RPM Header Reading
SWF — Shockwave Flash
Process Control Extensions
Eio
Ev
Expect
Libevent
PCNTL — Process Control
POSIX
Program execution — System program execution
pthreads
Semaphore — Semaphore, Shared Memory and IPC
Shared Memory
Other Basic Extensions
GeoIP — Geo IP Location
JSON — JavaScript Object Notation
Judy — Judy Arrays
Lua
Misc. — Miscellaneous Functions
Parsekit
SPL — Standard PHP Library (SPL)
SPL Types — SPL Type Handling
Streams
Tidy
Tokenizer
URLs
V8js — V8 Javascript Engine Integration
Yaml — YAML Data Serialization
Yaf
Taint
Other Services
AMQP
chdb — Constant hash database
cURL — Client URL Library
Event
FAM — File Alteration Monitor
FTP
Gearman
Gopher — Net Gopher
Gupnp
HTTP
Hyperwave
Hyperwave API
Java — PHP / Java Integration
LDAP — Lightweight Directory Access Protocol
Lotus Notes
Memcache
Memcached
mqseries
Network
RRD — RRDtool
SAM — Simple Asynchronous Messaging
SNMP
Sockets
SSH2 — Secure Shell2
Stomp — Stomp Client
SVM — Support Vector Machine
SVN — Subversion
TCP — TCP Wrappers
Varnish
YAZ
YP/NIS
Search Engine Extensions
mnoGoSearch
Solr — Apache Solr
Sphinx — Sphinx Client
Swish — Swish Indexing
Server Specific Extensions
Apache
IIS — IIS Administration
NSAPI
Session Extensions
Msession — Mohawk Software Session Handler Functions
Sessions — Session Handling
Session PgSQL — PostgreSQL Session Save Handler
Text Processing
BBCode — Bulletin Board Code
PCRE — Regular Expressions (Perl-Compatible)
POSIX Regex — Regular Expression (POSIX Extended)
ssdeep — ssdeep Fuzzy Hashing
Strings
Variable and Type Related Extensions
Arrays
Classes/Objects — Class/Object Information
Classkit
Ctype — Character type checking
Filter — Data Filtering
Function Handling
Object Aggregation — Object Aggregation/Composition [PHP 4]
Quickhash
Reflection
Variable handling
Web Services
OAuth
SCA
SOAP
XML-RPC
Windows Only Extensions
.NET
COM — COM and .Net (Windows)
Printer
W32api
win32ps
win32service
XML Manipulation
DOM — Document Object Model
libxml
qtdom
SDO — Service Data Objects
SDO-DAS-Relational — SDO Relational Data Access Service
SDO DAS XML — SDO XML Data Access Service
SimpleXML
WDDX
XML Parser
XMLReader
XMLWriter
XSL
XSLT (PHP 4)
[http://www.php.net/manual/en/funcref.php]

lcpPhp'function.

name::
* McsEngl.lcpPhp'function.@cptIt,
* McsEngl.lcpPhp'-function@cptIt,

lcpPhp'function.anonymous

name::
* McsEngl.lcpPhp'function.anonymous@cptIt,
* McsEngl.lcpPhp'anonymous-function@cptIt,
* McsEngl.lcpPhp'closure@cptIt,

_DESCRIPTION:
Anonymous functions, also known as closures, allow the creation of functions which have no specified name. They are most useful as the value of callback parameters, but they have many other uses.

Example#1 Anonymous function example
<?php
echo preg_replace_callback('~-([a-z])~', function ($match) {
return strtoupper($match[1]);
}, 'hello-world');
// outputs helloWorld
?>
Closures can also be used as the values of variables; PHP automatically converts such expressions into instances of the Closure internal class. Assigning a closure to a variable uses the same syntax as any other assignment, including the trailing semicolon:

Example#2 Anonymous function variable assignment example
<?php
$greet = function($name)
{
printf("Hello %s<br>", $name);
};

$greet('World');
$greet('PHP');
?>
[http://www.php.net/manual/en/functions.anonymous.php]

lcpPhp'function.Built-in

name::
* McsEngl.lcpPhp'function.Built-in@cptIt,
* McsEngl.lcpPhp'built-in-function@cptIt,
* McsEngl.lcpPhp'internal-function@cptIt,

lcpPhp'function.Example

name::
* McsEngl.lcpPhp'function.Example@cptIt,
* McsEngl.lcpPhp'ex.function@cptIt,

function myFunction() { //declares a function, this is named myFunction
return 'John Doe'; //returns the value 'John Doe'
}

<?php
function echoit($string)
{
echo $string;
}

echoit(1+1); // This echo 2
?>

lcpPhp'function.define

name::
* McsEngl.lcpPhp'function.define@cptIt,
* McsEngl.lcpPhp'define-function@cptIt,

_ENTITY:
* constant#ql:php'constant#

define

(PHP 4, PHP 5)

define — Defines a named constant

Report a bug
Description

bool define ( string $name , mixed $value [, bool $case_insensitive = false ] )
Defines a named constant at runtime.
[http://gr.php.net/manual/en/function.define.php]

lcpPhp'function.fread()

name::
* McsEngl.lcpPhp'function.fread()@cptIt,

$myFile = "testFile.txt";
$fh = fopen($myFile, 'r');
$theData = fread($fh, 9);
fclose($fh);
echo $theData;

lcpPhp'function.is-resource()

name::
* McsEngl.lcpPhp'function.is-resource()@cptIt,

lcpPhp'function.NETWORK

name::
* McsEngl.lcpPhp'function.NETWORK@cptIt,
* McsEngl.lcpPhp'network-function@cptIt,

_SPECIFIC:
Network Functions

Table of Contents

checkdnsrr — Check DNS records corresponding to a given Internet host name or IP address
closelog — Close connection to system logger
define_syslog_variables — Initializes all syslog related variables
dns_check_record — Alias of checkdnsrr
dns_get_mx — Alias of getmxrr
dns_get_record — Fetch DNS Resource Records associated with a hostname
fsockopen — Open Internet or Unix domain socket connection
gethostbyaddr — Get the Internet host name corresponding to a given IP address
gethostbyname — Get the IPv4 address corresponding to a given Internet host name
gethostbynamel — Get a list of IPv4 addresses corresponding to a given Internet host name
gethostname — Gets the host name
getmxrr — Get MX records corresponding to a given Internet host name
getprotobyname — Get protocol number associated with protocol name
getprotobynumber — Get protocol name associated with protocol number
getservbyname — Get port number associated with an Internet service and protocol
getservbyport — Get Internet service which corresponds to port and protocol
header_register_callback — Call a header function
header_remove — Remove previously set headers
header — Send a raw HTTP header
headers_list — Returns a list of response headers sent (or ready to send)
headers_sent — Checks if or where headers have been sent
http_response_code — Get or Set the HTTP response code
inet_ntop — Converts a packed internet address to a human readable representation
inet_pton — Converts a human readable IP address to its packed in_addr representation
ip2long — Converts a string containing an (IPv4) Internet Protocol dotted address into a proper address
long2ip — Converts an (IPv4) Internet network address into a string in Internet standard dotted format
openlog — Open connection to system logger
pfsockopen — Open persistent Internet or Unix domain socket connection
setcookie — Send a cookie
setrawcookie — Send a cookie without urlencoding the cookie value
socket_get_status — Alias of stream_get_meta_data
socket_set_blocking — Alias of stream_set_blocking
socket_set_timeout — Alias of stream_set_timeout
syslog — Generate a system log message
[http://www.php.net/manual/en/ref.network.php]

lcpPhp'function.phpinfo()

name::
* McsEngl.lcpPhp'function.phpinfo()@cptIt,
* McsEngl.lcpPhp'phpinfo-function@cptIt,

lcpPhp'function.Recursive

name::
* McsEngl.lcpPhp'function.Recursive@cptIt,

<?php
function recursion($a)
{
if ($a < 20) {
echo "$a\n";
recursion($a + 1);
}
}
?>
[http://www.php.net/manual/en/functions.user-defined.php]

lcpPhp'function.user-defined

name::
* McsEngl.lcpPhp'function.user-defined@cptIt,
* McsEngl.lcpPhp'user-defined-function@cptIt,

lcpPhp'function.variable

name::
* McsEngl.lcpPhp'function.variable@cptIt,
* McsEngl.lcpPhp'variable-function@cptIt,

_DESCRIPTION:
PHP supports the concept of variable functions. This means that if a variable name has parentheses appended to it, PHP will look for a function with the same name as whatever the variable evaluates to, and will attempt to execute it. Among other things, this can be used to implement callbacks, function tables, and so forth.

Variable functions won't work with language constructs such as echo(), print(), unset(), isset(), empty(), include(), require() and the like. Utilize wrapper functions to make use of any of these constructs as variable functions.

Example#1 Variable function example
<?php
function foo() {
echo "In foo()<br />\n";
}

function bar($arg = '')
{
echo "In bar(); argument was '$arg'.<br />\n";
}

// This is a wrapper function around echo
function echoit($string)
{
echo $string;
}

$func = 'foo';
$func(); // This calls foo()

$func = 'bar';
$func('test'); // This calls bar()

$func = 'echoit';
$func('test'); // This calls echoit()
?>
[http://www.php.net/manual/en/functions.variable-functions.php]

lcpPhp'function.variable-management

name::
* McsEngl.lcpPhp'function.variable-management@cptIt,

Variable handling Functions

Table of Contents

debug_zval_dump — Dumps a string representation of an internal zend value to output
doubleval — Alias of floatval
empty — Determine whether a variable is empty
floatval — Get float value of a variable
get_defined_vars — Returns an array of all defined variables
get_resource_type — Returns the resource type
gettype — Get the type of a variable
import_request_variables — Import GET/POST/Cookie variables into the global scope
intval — Get the integer value of a variable
is_array — Finds whether a variable is an array
is_bool — Finds out whether a variable is a boolean
is_callable — Verify that the contents of a variable can be called as a function
is_double — Alias of is_float
is_float — Finds whether the type of a variable is float
is_int — Find whether the type of a variable is integer
is_integer — Alias of is_int
is_long — Alias of is_int
is_null — Finds whether a variable is NULL
is_numeric — Finds whether a variable is a number or a numeric string
is_object — Finds whether a variable is an object
is_real — Alias of is_float
is_resource — Finds whether a variable is a resource
is_scalar — Finds whether a variable is a scalar
is_string — Find whether the type of a variable is string
isset — Determine if a variable is set and is not NULL
print_r — Prints human-readable information about a variable
serialize — Generates a storable representation of a value
settype — Set the type of a variable
strval — Get string value of a variable
unserialize — Creates a PHP value from a stored representation
unset — Unset a given variable
var_dump — Dumps information about a variable
var_export — Outputs or returns a parsable string representation of a variable
[http://www.php.net/manual/en/ref.var.php]

lcpPhp'number.code

name::
* McsEngl.lcpPhp'number.code@cptIt,
* McsEngl.lcpPhp'code.NUMBER@cptIt,
* McsEngl.lcpPhp'data.NUMBER@cptIt,
* McsEngl.lcpPhp'number@cptIt,

_GENERIC:
* pseudo-datatype,

_DESCRIPTION:
number indicates that a parameter can be either integer or float.
[http://www.php.net/manual/en/language.pseudo-types.php#language.types.number]

_SPECIFIC:
* float#ql:php'float#,
* integer#ql:php'integer#

lcpPhp'data.number.FLOAT

name::
* McsEngl.lcpPhp'data.number.FLOAT@cptIt,
* McsEngl.lcpPhp'double@cptIt,
* McsEngl.lcpPhp'float@cptIt,
* McsEngl.lcpPhp'floating-point-number@cptIt,
* McsEngl.lcpPhp'real-number@cptIt,

_GENERIC:
* number#ql:php'number#

_DESCRIPTION:
Floating point numbers (also known as "floats", "doubles", or "real numbers") can be specified using any of the following syntaxes:

<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
[http://www.php.net/manual/en/language.types.float.php]

lcpPhp'data.number.INTEGER

name::
* McsEngl.lcpPhp'data.number.INTEGER@cptIt,
* McsEngl.lcpPhp'integer@cptIt,

_GENERIC:
* number#ql:php'number#

_DESCRIPTION:
An integer is a number of the set Z = {..., -2, -1, 0, 1, 2, ...}.
[http://www.php.net/manual/en/language.types.integer.php]

_NOTATION:
Integers can be specified in decimal (base 10), hexadecimal (base 16), octal (base 8) or binary (base 2) notation, optionally preceded by a sign (- or +).

Binary integer literals are available since PHP 5.4.0.

To use octal notation, precede the number with a 0 (zero). To use hexadecimal notation precede the number with 0x. To use binary notation precede the number with 0b.
[http://www.php.net/manual/en/language.types.integer.php#language.types.integer.syntax]

_INTEGER:
Integer literals
<?php
$a = 1234; // decimal number
$a = -123; // a negative number
$a = 0123; // octal number (equivalent to 83 decimal)
$a = 0x1A; // hexadecimal number (equivalent to 26 decimal)
?>

phpresource'function

name::
* McsEngl.phpresource'function@cptIt,

_SPECIFIC:
The function is_resource() can be used to determine if a variable is a resource and get_resource_type() will return the type of resource it is.
[http://www.php.net/manual/en/resource.php]

phpresource'type

name::
* McsEngl.phpresource'type@cptIt,

_DESCRIPTION:
The following is a list of functions which create, use or destroy PHP resources. The function is_resource() can be used to determine if a variable is a resource and get_resource_type() will return the type of resource it is.
[http://www.php.net/manual/en/resource.php]

lcpPhp'string'code

name::
* McsEngl.lcpPhp'string'code@cptIt,
* McsEngl.lcpPhp'code.STRING@cptIt,
* McsEngl.lcpPhp'data.STRING@cptIt,
* McsEngl.lcpPhp'string-code@cptIt,
* McsEngl.lcpPhp'string@cptIt,
* McsEngl.lcpPhp'text@cptIt,

_CODE:
$x = "Hello world!";
$x = 'Hello world!';

_DESCRIPTION:
A string is series of characters, where a character is the same as a byte. This means that PHP only supports a 256-character set, and hence does not offer native Unicode support. See details of the string type.
Note: It is no problem for a string to become very large. PHP imposes no boundary on the size of a string; the only limit is the available memory of the computer on which PHP is running.
[http://www.php.net/manual/en/language.types.string.php]

_ATTRIBUTE:
* string-function#ql:lcpphp'string'function#,
* string-operator#ql:lcpphp'operator.string#

lcpPhp'string'function

name::
* McsEngl.lcpPhp'string'function@cptIt,
* McsEngl.lcpPhp'function.String@cptIt,
* McsEngl.lcpPhp'string'function@cptIt,

_ADDRESS.WPG:
* http://gr.php.net/manual/en/ref.strings.php,
* http://www.w3schools.com/php/php_ref_string.asp,

_SPECIFIC:
addcslashes — Quote string with slashes in a C style
addslashes — Quote string with slashes
bin2hex — Convert binary data into hexadecimal representation
chop — Alias of rtrim
chr — Return a specific character
chunk_split — Split a string into smaller chunks
convert_cyr_string — Convert from one Cyrillic character set to another
convert_uudecode — Decode a uuencoded string
convert_uuencode — Uuencode a string
count_chars — Return information about characters used in a string
crc32 — Calculates the crc32 polynomial of a string
crypt — One-way string hashing
echo — Output one or more strings
explode — Split a string by string
fprintf — Write a formatted string to a stream
get_html_translation_table — Returns the translation table used by htmlspecialchars and htmlentities
hebrev — Convert logical Hebrew text to visual text
hebrevc — Convert logical Hebrew text to visual text with newline conversion
hex2bin — Convert hex to binary
html_entity_decode — Convert all HTML entities to their applicable characters
htmlentities — Convert all applicable characters to HTML entities
htmlspecialchars_decode — Convert special HTML entities back to characters
htmlspecialchars — Convert special characters to HTML entities
implode — Join array elements with a string
join — Alias of implode
lcfirst — Make a string's first character lowercase
levenshtein — Calculate Levenshtein distance between two strings
localeconv — Get numeric formatting information
ltrim — Strip whitespace (or other characters) from the beginning of a string
md5_file — Calculates the md5 hash of a given file
md5 — Calculate the md5 hash of a string
metaphone — Calculate the metaphone key of a string
money_format — Formats a number as a currency string
nl_langinfo — Query language and locale information
nl2br — Inserts HTML line breaks before all newlines in a string
number_format — Format a number with grouped thousands
ord — Return ASCII value of character
parse_str — Parses the string into variables
print — Output a string
printf — Output a formatted string
quoted_printable_decode — Convert a quoted-printable string to an 8 bit string
quoted_printable_encode — Convert a 8 bit string to a quoted-printable string
quotemeta — Quote meta characters
rtrim — Strip whitespace (or other characters) from the end of a string
setlocale — Set locale information
sha1_file — Calculate the sha1 hash of a file
sha1 — Calculate the sha1 hash of a string
similar_text — Calculate the similarity between two strings
soundex — Calculate the soundex key of a string
sprintf — Return a formatted string
sscanf — Parses input from a string according to a format
str_getcsv — Parse a CSV string into an array
str_ireplace — Case-insensitive version of str_replace.
str_pad — Pad a string to a certain length with another string
str_repeat — Repeat a string
str_replace — Replace all occurrences of the search string with the replacement string
str_rot13 — Perform the rot13 transform on a string
str_shuffle — Randomly shuffles a string
str_split — Convert a string to an array
str_word_count — Return information about words used in a string
strcasecmp — Binary safe case-insensitive string comparison
strchr — Alias of strstr
strcmp — Binary safe string comparison
strcoll — Locale based string comparison
strcspn — Find length of initial segment not matching mask
strip_tags — Strip HTML and PHP tags from a string
stripcslashes — Un-quote string quoted with addcslashes
stripos — Find the position of the first occurrence of a case-insensitive substring in a string
stripslashes — Un-quotes a quoted string
stristr — Case-insensitive strstr
strlen — Get string length
strnatcasecmp — Case insensitive string comparisons using a "natural order" algorithm
strnatcmp — String comparisons using a "natural order" algorithm
strncasecmp — Binary safe case-insensitive string comparison of the first n characters
strncmp — Binary safe string comparison of the first n characters
strpbrk — Search a string for any of a set of characters
strpos — Find the position of the first occurrence of a substring in a string
strrchr — Find the last occurrence of a character in a string
strrev — Reverse a string
strripos — Find the position of the last occurrence of a case-insensitive substring in a string
strrpos — Find the position of the last occurrence of a substring in a string
strspn — Finds the length of the initial segment of a string consisting entirely of characters contained within a given mask.
strstr — Find the first occurrence of a string
strtok — Tokenize string
strtolower — Make a string lowercase
strtoupper — Make a string uppercase
strtr — Translate characters or replace substrings
substr_compare — Binary safe comparison of two strings from an offset, up to length characters
substr_count — Count the number of substring occurrences
substr_replace — Replace text within a portion of a string
substr — Return part of a string
trim — Strip whitespace (or other characters) from the beginning and end of a string
ucfirst — Make a string's first character uppercase
ucwords — Uppercase the first character of each word in a string
vfprintf — Write a formatted string to a stream
vprintf — Output a formatted string
vsprintf — Return a formatted string
wordwrap — Wraps a string to a given number of characters
[http://gr.php.net/manual/en/ref.strings.php]

lcpPhp'string'operator

name::
* McsEngl.lcpPhp'string'operator@cptIt,
* McsEngl.lcpPhp'operator.STRING@cptIt,
* McsEngl.lcpPhp'string-operator@cptIt,
* McsEngl.php'operator.string@cptIt,

_ENTITY:
* string#ql:php'string#

_DESCRIPTION:
There are two string operators. The first is the concatenation operator ('.'), which returns the concatenation of its right and left arguments. The second is the concatenating assignment operator ('.='), which appends the argument on the right side to the argument on the left side. Please read Assignment Operators for more information.

<?php
$a = "Hello ";
$b = $a . "World!"; // now $b contains "Hello World!"

$a = "Hello ";
$a .= "World!"; // now $a contains "Hello World!"
?>
[http://www.php.net/manual/en/language.operators.string.php]
The Concatenation Operator

There is only one string operator in PHP.

The concatenation operator (.) is used to put two string values together.

To concatenate two string variables together, use the concatenation operator:

<?php
$txt1="Hello World!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2;
?>
The output of the code above will be:

Hello World! What a nice day!
[http://www.w3schools.com/php/php_string.asp]

lcpPhp'string'splitting-into-words

name::
* McsEngl.lcpPhp'string'splitting-into-words@cptIt,

_CODE.PHP
// The RegEx to split a chunk of text into words
 public static $regex = '/[\p{L}\p{N}]+|[^\p{L}\p{N}]/u';

lcpPhp'string.CHARACTER

name::
* McsEngl.lcpPhp'string.CHARACTER@cptIt,
* McsEngl.lcpPhp'data.CHARACTER@cptIt,
* McsEngl.lcpPhp'character@cptIt,

_DESCRIPTION:
A string is series of characters, where a character is the same as a byte. This means that PHP only supports a 256-character set, and hence does not offer native Unicode support. See details of the string type.
[http://www.php.net/manual/en/language.types.string.php]

lcpPhp'archetype'type'casting

name::
* McsEngl.lcpPhp'archetype'type'casting@cptIt,

Type Casting ¶

Type casting in PHP works much as it does in C: the name of the desired type is written in parentheses before the variable which is to be cast.

<?php
$foo = 10; // $foo is an integer
$bar = (boolean) $foo; // $bar is a boolean
?>
The casts allowed are:

(int), (integer) - cast to integer
(bool), (boolean) - cast to boolean
(float), (double), (real) - cast to float
(string) - cast to string
(array) - cast to array
(object) - cast to object
(unset) - cast to NULL (PHP 5)
(binary) casting and b prefix forward support was added in PHP 5.2.1
[http://www.php.net/manual/en/language.types.type-juggling.php#language.types.typecasting]

lcpPhp'variable'code

name::
* McsEngl.lcpPhp'variable'code@cptIt,
* McsEngl.lcpPhp'code.VARIABLE@cptIt,
* McsEngl.lcpPhp'variable@cptIt,

_GENERIC:
* container-code#ql:php'container_code#,
* codetype#ql:php'codetype#

_DESCRIPTION:
A variable is a storage area holding a number or text. The problem is, a variable will hold only one value.
[http://www.w3schools.com/php/php_arrays.asp]
===
A variable is a means of storing a value, such as text string "Hello World!" or the integer value 4. A variable can then be reused throughout your code, instead of having to type out the actual value over and over again. In PHP you define a variable with the following form:
$variable_name = Value;
[http://www.tizag.com/phpT/variable.php]
===
Variables in PHP are represented by a dollar sign followed by the name of the variable. The variable name is case-sensitive.
Variable names follow the same rules as other labels in PHP. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
[http://www.php.net/manual/en/language.variables.basics.php]

lcpPhp'variable'declaration

name::
* McsEngl.lcpPhp'variable'declaration@cptIt,

_DESCRIPTION:
PHP does not require (or support) explicit type definition in variable declaration; a variable's type is determined by the context in which the variable is used. That is to say, if a string value is assigned to variable $var, $var becomes a string. If an integer value is then assigned to $var, it becomes an integer.

An example of PHP's automatic type conversion is the addition operator '+'. If either operand is a float, then both operands are evaluated as floats, and the result will be a float. Otherwise, the operands will be interpreted as integers, and the result will also be an integer. Note that this does not change the types of the operands themselves; the only change is in how the operands are evaluated and what the type of the expression itself is.

<?php
$foo = "0"; // $foo is string (ASCII 48)
$foo += 2; // $foo is now an integer (2)
$foo = $foo + 1.3; // $foo is now a float (3.3)
$foo = 5 + "10 Little Piggies"; // $foo is integer (15)
$foo = 5 + "10 Small Pigs"; // $foo is integer (15)
?>
[http://www.php.net/manual/en/language.types.type-juggling.php#language.types.type-juggling]

_CODE.PHP:
$x=5;
$y=6;
$z=$x+$y;

lcpPhp'variable'function

name::
* McsEngl.lcpPhp'variable'function@cptIt,

_ADDRESS.WPG:
* http://gr.php.net/manual/en/ref.var.php,

_DESCRIPTION:
PHP supports the concept of variable functions. This means that if a variable name has parentheses appended to it, PHP will look for a function with the same name as whatever the variable evaluates to, and will attempt to execute it. Among other things, this can be used to implement callbacks, function tables, and so forth.

Variable functions won't work with language constructs such as echo, print, unset(), isset(), empty(), include, require and the like. Utilize wrapper functions to make use of any of these constructs as variable functions.

Example#1 Variable function example

<?php
function foo() {
echo "In foo()<br />\n";
}

function bar($arg = '')
{
echo "In bar(); argument was '$arg'.<br />\n";
}

// This is a wrapper function around echo
function echoit($string)
{
echo $string;
}

$func = 'foo';
$func(); // This calls foo()

$func = 'bar';
$func('test'); // This calls bar()

$func = 'echoit';
$func('test'); // This calls echoit()
?>
[http://php.net/functions.variable-functions]

_SPECIFIC:
* lcpPhp'debug_zval_dump — Dumps a string representation of an internal zend value to output
* lcpPhp'doubleval — Alias of floatval
* lcpPhp'empty — Determine whether a variable is empty
* lcpPhp'floatval — Get float value of a variable
* lcpPhp'get_defined_vars — Returns an array of all defined variables
* lcpPhp'get_resource_type — Returns the resource type
* lcpPhp'gettype — Get the type of a variable
* lcpPhp'import_request_variables — Import GET/POST/Cookie variables into the global scope
* lcpPhp'intval — Get the integer value of a variable
* lcpPhp'is_array — Finds whether a variable is an array
* lcpPhp'is_bool — Finds out whether a variable is a boolean
* lcpPhp'is_callable — Verify that the contents of a variable can be called as a function
* lcpPhp'is_double — Alias of is_float
* lcpPhp'is_float — Finds whether the type of a variable is float
* lcpPhp'is_int — Find whether the type of a variable is integer
* lcpPhp'is_integer — Alias of is_int
* lcpPhp'is_long — Alias of is_int
* lcpPhp'is_null — Finds whether a variable is NULL
* lcpPhp'is_numeric — Finds whether a variable is a number or a numeric string
* lcpPhp'is_object — Finds whether a variable is an object
* lcpPhp'is_real — Alias of is_float
* lcpPhp'is_resource — Finds whether a variable is a resource
* lcpPhp'is_scalar — Finds whether a variable is a scalar
* lcpPhp'is_string — Find whether the type of a variable is string
* lcpPhp'isset — Determine if a variable is set and is not NULL
* lcpPhp'print_r — Prints human-readable information about a variable
* lcpPhp'serialize — Generates a storable representation of a value
* lcpPhp'settype — Set the type of a variable
* lcpPhp'strval — Get string value of a variable
* lcpPhp'unserialize — Creates a PHP value from a stored representation
* lcpPhp'unset — Unset a given variable
* lcpPhp'var_dump — Dumps information about a variable
* lcpPhp'var_export — Outputs or returns a parsable string representation of a variable
[http://gr.php.net/manual/en/ref.var.php]

lcpPhp'variable'name

name::
* McsEngl.lcpPhp'variable'name@cptIt,
* McsEngl.lcpPhp'variable'Reference@cptIt,
* McsEngl.lcpPhp'reference@cptIt,

_DESCRIPTION:
If you forget that dollar sign at the beginning, it will not work. This is a common mistake for new PHP programmers!
Note: Also, variable names are case-sensitive, so use the exact same capitalization when using a variable. The variables $a_number and $A_number are different variables in PHP's eyes.
[http://www.tizag.com/phpT/variable.php]
===
References in PHP are a means to access the same variable content by different names. They are not like C pointers; for instance, you cannot perform pointer arithmetic using them, they are not actual memory addresses, and so on. See What References Are Not for more information. Instead, they are symbol table aliases. Note that in PHP, variable name and variable content are different, so the same content can have different names. The closest analogy is with Unix filenames and files - variable names are directory entries, while variable content is the file itself. References can be likened to hardlinking in Unix filesystem.
[http://www.php.net/manual/en/language.references.whatare.php]

lcpPhp'variable'scope

name::
* McsEngl.lcpPhp'variable'scope@cptIt,

lcpPhp'variable'type

name::
* McsEngl.lcpPhp'variable'type@cptIt,
* McsEngl.lcpPhp'type-of-variable@cptIt,

_DESCRIPTION:
PHP does not require (or support) explicit type definition in variable declaration; a variable's type is determined by the context in which the variable is used. That is to say, if a string value is assigned to variable $var, $var becomes a string. If an integer value is then assigned to $var, it becomes an integer.
[http://www.php.net/manual/en/language.types.type-juggling.php]
===
The type of a variable is not usually set by the programmer; rather, it is decided at runtime by PHP depending on the context in which that variable is used.
[http://www.php.net/manual/en/language.types.intro.php]

_SPECIFIC:
Possibles values of type are:

"boolean" (or, since PHP 4.2.0, "bool")
"integer" (or, since PHP 4.2.0, "int")
"float" (only possible since PHP 4.2.0, for older versions use the deprecated variant "double")
"string"
"array"
"object"
"null" (since PHP 4.2.0)
[http://www.php.net/manual/en/function.settype.php]

lcpPhp'variable'value

name::
* McsEngl.lcpPhp'variable'value@cptIt,
* McsEngl.lcpPhp'value@cptIt,
* McsEngl.lcpPhp'variable'value@cptIt,

SPECIFIC

_SPECIFIC:
* data-variable,
* lcpPhp'variable.SPECIFIC,
* processing-variable,
* mixed-variable,

lcpPhp'variable.Data

name::
* McsEngl.lcpPhp'variable.Data@cptIt,

lcpPhp'variable.GLOBAL

name::
* McsEngl.lcpPhp'variable.GLOBAL@cptIt,
* McsEngl.lcpPhp'global-variable@cptIt,

_DESCRIPTION:
The global keyword

First, an example use of global:

Example#1 Using global
<?php
$a = 1;
$b = 2;

function Sum()
{
global $a, $b;

$b = $a + $b;
}

Sum();
echo $b;
?>
The above script will output 3. By declaring $a and $b global within the function, all references to either variable will refer to the global version. There is no limit to the number of global variables that can be manipulated by a function.

A second way to access variables from the global scope is to use the special PHP-defined $GLOBALS array. The previous example can be rewritten as:

Example#2 Using $GLOBALS instead of global
<?php
$a = 1;
$b = 2;

function Sum()
{
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

Sum();
echo $b;
?>
The $GLOBALS array is an associative array with the name of the global variable being the key and the contents of that variable being the value of the array element. Notice how $GLOBALS exists in any scope, this is because $GLOBALS is a superglobal.
[http://php.net/manual/en/language.variables.scope.php]

lcpPhp'variable.LOCAL

name::
* McsEngl.lcpPhp'variable.LOCAL@cptIt,

_CODE.PHP:
<?php

function myTest() {
$x=0;
echo $x . "<br/>";
$x++;
}

myTest(); //0
myTest(); //0
myTest(); //0

?>

lcpPhp'variable.Mixed

name::
* McsEngl.lcpPhp'variable.Mixed@cptIt,

lcpPhp'variable.Predefined

name::
* McsEngl.lcpPhp'variable.Predefined@cptIt,
* McsEngl.lcpPhp'predefined-variable@cptIt,
* McsEngl.lcpPhp'reserved-variable@cptIt,

_DESCRIPTION:
Predefined Variables

PHP provides a large number of predefined variables to all scripts. The variables represent everything from external variables to built-in environment variables, last error messages to last retrieved headers.

See also the FAQ titled "How does register_globals affect me?"

Table of Contents
Superglobals — Superglobals are built-in variables that are always available in all scopes
$GLOBALS — References all variables available in global scope
$_SERVER — Server and execution environment information
$_GET — HTTP GET variables
$_POST — HTTP POST variables
$_FILES — HTTP File Upload variables
$_REQUEST — HTTP Request variables
$_SESSION — Session variables
$_ENV — Environment variables
$_COOKIE — HTTP Cookies
$php_errormsg — The previous error message
$HTTP_RAW_POST_DATA — Raw POST data
$http_response_header — HTTP response headers
$argc — The number of arguments passed to script
$argv — Array of arguments passed to script
[http://www.php.net/manual/en/reserved.variables.php]
===
PHP provides a large number of predefined variables to any script which it runs. Many of these variables, however, cannot be fully documented as they are dependent upon which server is running, the version and setup of the server, and other factors. Some of these variables will not be available when PHP is run on the command line. For a listing of these variables, please see the section on Reserved Predefined Variables.
[http://www.php.net/manual/en/language.variables.predefined.php]

lcpPhp'variable.Processing

name::
* McsEngl.lcpPhp'variable.Processing@cptIt,

lcpPhp'variable.Resource

name::
* McsEngl.lcpPhp'variable.Resource@cptIt,
* McsEngl.lcpPhp'resource-variable@cptIt,

_DESCRIPTION:
A resource is a special variable, holding a reference to an external resource. Resources are created and used by special functions.
[http://gr.php.net/manual/en/language.types.resource.php]

_Function:
* string get_resource_type ( resource $handle )
* bool is_resource ( mixed $var ):

lcpPhp'variable.STATIC

name::
* McsEngl.lcpPhp'variable.STATIC@cptIt,

_DESCRIPTION:
Makes a local global.

_CODE.PHP:
<?php

function myTest() {
static $x=0;
echo $x . "<br/>";
$x++;
}

myTest(); //0
myTest(); //1
myTest(); //1

?>

lcpPhp'variable.SUPERGLOBAL

name::
* McsEngl.lcpPhp'variable.SUPERGLOBAL@cptIt,
* McsEngl.lcpPhp'superglobal-variable@cptIt,

_DESCRIPTION:
Superglobals

Superglobals — Superglobals are built-in variables that are always available in all scopes
Description ¶

Several predefined variables in PHP are "superglobals", which means they are available in all scopes throughout a script. There is no need to do global $variable; to access them within functions or methods.

These superglobal variables are:

$GLOBALS
$_SERVER
$_GET
$_POST
$_FILES
$_COOKIE
$_SESSION
$_REQUEST
$_ENV
[http://www.php.net/manual/en/language.variables.superglobals.php]

lcpPhp'code.SPECIFIC-DIVISION.structure

name::
* McsEngl.lcpPhp'code.SPECIFIC-DIVISION.structure@cptIt,

_SPECIFIC:
* directory
* file
* program
* sentence-structure
* sentence
* atom-structure
* atom
* unit-structure
* unit

lcpPhp'code.EXPRESSION

name::
* McsEngl.lcpPhp'code.EXPRESSION@cptIt,
* McsEngl.lcpPhp'expression@cptIt,

_DESCRIPTION:
Expressions are the most important building stones of PHP. In PHP, almost anything you write is an expression. The simplest yet most accurate way to define an expression is "anything that has a value".
The most basic forms of expressions are constants and variables. When you type "$a = 5", you're assigning '5' into $a. '5', obviously, has the value 5, or in other words '5' is an expression with the value of 5 (in this case, '5' is an integer constant).
...
PHP takes expressions much further, in the same way many other languages do. PHP is an expression-oriented language, in the sense that almost everything is an expression. Consider the example we've already dealt with, '$a = 5'. It's easy to see that there are two values involved here, the value of the integer constant '5', and the value of $a which is being updated to 5 as well. But the truth is that there's one additional value involved here, and that's the value of the assignment itself. The assignment itself evaluates to the assigned value, in this case 5. In practice, it means that '$a = 5', regardless of what it does, is an expression with the value 5. Thus, writing something like '$b = ($a = 5)' is like writing '$a = 5; $b = 5;' (a semicolon marks the end of a statement). Since assignments are parsed in a right to left order, you can also write '$b = $a = 5'.
[http://www.php.net/manual/en/language.expressions.php]

_SPECIFIC:
* constant,
* function,
* statement#ql:php'statement#,
* variable,

lcpPhp'code.MIXED

name::
* McsEngl.lcpPhp'code.MIXED@cptIt,
* McsEngl.lcpPhp'Mixed-code@cptIt,

_GENERIC:
* php-code#ql:php'code#

_SPECIFIC:
* class#ql:lcpphp'class#

lcpPhp'Arithmetic

name::
* McsEngl.lcpPhp'Arithmetic@cptIt,

lcpPhp'Boolean

name::
* McsEngl.lcpPhp'Boolean@cptIt,

lcpPhp'Comparison

name::
* McsEngl.lcpPhp'Comparison@cptIt,

lcpPhp'Container

name::
* McsEngl.lcpPhp'Container@cptIt,

lcpPhp'Converting-datatype

name::
* McsEngl.lcpPhp'Converting-datatype@cptIt,

lcpPhp'FILE-MANAGER

name::
* McsEngl.lcpPhp'FILE-MANAGER@cptIt,
* McsEngl.lcpPhp'ex.file-manager@cptIt,

_SPECIFIC:
* http://extplorer.net//
* http://extplorer.sourceforge.net//

lcpPhp'file.upload

name::
* McsEngl.lcpPhp'file.upload@cptIt,
* McsEngl.lcpPhp'ex.file.upload@cptIt,

_ADDRESS.WPG:
* http://phpfileuploader.com//
* http://www.tizag.com/phpT/fileupload.php,
* http://www.phpeasystep.com/phptu/1.html,
* http://www.w3schools.com/php/php_file_upload.asp,

lcpPhp'login-code

name::
* McsEngl.lcpPhp'login-code@cptIt,

_ADDRESS.WPG:
* http://www.9lessons.info/2009/09/php-login-page-example.html, with demo.
* http://www.phpeasystep.com/phptu/6.html,
* http://phpcodeforbeginner.blogspot.gr/2012/10/php-simple-login-form-php-tutorial-for.html,

<?php
$xdebug=0;
if ($xdebug==1)
{
print "POST<br />";
while (list($k,$v) = each($_POST))
{
print ($k . ": " . $v . "<br />");
}
print "REQUEST<br />";
while (list($k,$v)=each ($_REQUEST))
{
print ($k . ": " . $v . "<br />");
}
}
main();
function main()
{

if (isset($_REQUEST["username"]) && isset($_REQUEST["password"]))
{
$username=$_REQUEST["username"];
$password=$_REQUEST["password"];
//print ("username: " . $username . "<br />");
//print ("password: " . $password . "<br />");
connect_ftp($username, $password);
}
elseif (isset($_POST["username"]) && isset($_POST["password"]))
{

$username=$_POST["username"];
$password=$_POST["password"];
//print ("username: " . $username . "<br />");
//print ("password: " . $password . "<br />");
connect_ftp($username, $password);
}

else
{
print "User name/password not set<br />";
}

}



// function to give dir listing stuff
function dir_funk ($username, $password,$ftp) {




// dir name
$dir=ftp_pwd($ftp);
// dir listing array
$dirlist=ftp_rawlist($ftp,$dir);

// print the directory listing
$funk = "<html><body><p>current directory: <b> $dir </b></p>";
$funk .= "<p><a href=\"ftp.php?&updir=$dir\">go up one level</a>
</p>";

$funk .= "<p>
<table cellspacing=0 cellpadding=2 border=1>
<tr><td><b>permissions</b></td><td><b>file/directory</b></td>
<td><b>download</b></td><td><b>delete</b></td>
<td><b>chmod</b></td><td><b>rename</b></td>
</tr>
";

while(list($i,$thingy)=each($dirlist)) {

$thingy=preg_replace("/\s+/", " ", $thingy);

if($i==0) {
echo "";
} else {
list($chmod,$thing,$owner,$group,$size,$month,$day,$time,$filename)=explode(" ",$thingy);
if(ereg("d",$chmod)) {
$funk .= "<tr><td>$chmod</td><td><a href=\"ftp.php?dir=$dir/$filename\">$filename</a></td>
<td>dir</td>


<td><a href=\"ftp.php?delete=dir&thingy=$dir/$filename\">delete</a></td>
<td><a href=\"ftp.php?chmod=1&thingy=$dir/$filename\">chmod</a></td>
<td><a href=\"ftp.php?rename=$dir/$filename\">rename</a></td>
</tr>";
} else {
$funk .= "<tr><td>$chmod</td><td>$filename</td>
<td><a href=\"ftp.php?dl=1&file=$dir/$filename\">d/l ($size)</a></td>
<td><a href=\"ftp.php?delete=file&thingy=$dir/$filename\">delete</a></td>
<td><a href=\"ftp.php?chmod=1&thingy=$dir/$filename\">chmod</a></td>
<td><a href=\"ftp.php?rename=$dir/$filename\">rename</a></td>
</tr>";
}
}

}

$funk .= "</table></p>";

$funk .= "<p>Create a new directory<br>
<form action=\"ftp.php\" method=\"POST\">
<input type=\"hidden\" name=\"username\" value=\"$username\">
<input type=\"hidden\" name=\"password\" value=\"$password\">

<input size=\"15\" name=\"name\">
<input type=\"hidden\" name=\"current_dir\" value=\"$dir\">
<input type=\"submit\" name=\"newdir\" value=\"create_dir\">
</form></p>";

$funk .= "<p>Upload a local file<br>
<form action=\"ftp.php\" method=\"POST\">
<input type=\"file\" name=\"localfile\"><br>
<input type=\"hidden\" name=\"current_dir\" value=\"$dir\">
<input type=\"submit\" name=\"upload\" value=\"upload_file\">
</form></p>";


$funk .= "</body></html>";

return $funk;
}


function print_login_form()
{
echo "<html><body><p><b>ftp login</b><hr></p>
<form method=\"POST\">
<p>Your server (eg ft)<br> <input size=\"30\" name=\"server\"></p>
<p>Username <br> <input size=\"30\" name=\"username\"></p>
<p>Password <br> <input size=\"30\" name=\"password\"></p>
<p><input type=\"submit\" name=\"login\" value=\"login\"></p>
</form></body></html>";
}

function connect_ftp($username, $password)
{
//print $username . "<br />";
//print $password . "<br />";

if (isset($_REQUEST["thingy"]))
{
$thingy= $_REQUEST["thingy"];
}


//** charles do above for vars below
/*
$_REQUEST["thingy"]
$_REQUEST["chmod"]
$_REQUEST["rename"]
$_REQUEST["dl"]
$_REQUEST["delete"]
$_REQUEST["updir"]
$_REQUEST["dir"]

*/
if (isset($_POST["dir"]))
{
$dir=$_POST["dir"];
}

if (isset ($_POST["upload"]))
{
$upload=$_POST["upload"];
}
if (isset($_POST["localfile"]))
{
$localfile=$_POST["localfile"];
}
if (isset($_POST["current_dir"]))
{
$current_dir=$_POST["current_dir"];
}
if (isset($_POST["newdir"])) {
$newdir=$_POST["newdir"];
}
if (isset($_POST["file"])) {
$file=$_POST["file"];
}
if (isset($_POST["dir"])) {
$dir=$_POST["dir"];
}

if (isset($_POST["local"])) {
$local=$_POST["local"];
}
if (isset($_POST["dl"])) {
$dl = $_POST["dl"];
}
if (isset($_POST["get"]))
{
$get = $_POST["get"];
}

/// Charles do this for these vars too: delete, thingy, chmod, filename
if (isset($_REQUEST["thingy"]))
{
$dl=$_REQUEST["dl"];
}



// try to connect or die with an error
$server="ftp.lunarstudio.com";
$ftp=ftp_connect($server) or die("invalid server");
// try to login or die with error
$conn=ftp_login($ftp,$username,$password) or die("login failed for some reason");
// set a cookie so the !$login form above is never displayed
setcookie("login","active");
// set goody cookies
setcookie("server",$server);
setcookie("username",$username);
setcookie("password",$password);


if($dir) {

ftp_chdir($ftp,$dir);
echo dir_funk($username, $password,$ftp);

} elseif($dl) {

if($get) {

if(!$local) {
die("please enter a value");
}

ftp_get($ftp, $local, $file, FTP_BINARY);
echo funk_die(normal);

} else {
echo "<html><body>";
echo "download file";
$size=ftp_size($ftp,$file);
$time=ftp_mdtm($ftp,$file);
$time=date("d M Y, H i",$time);
echo "<p><table cellspacing=0 cellpadding=2 border=1>
<tr><td><b>filename</b></td><td><b>size</b></td>
<td><b>date modified</b></td></tr>
<tr><td>$file</td><td>$size</td><td>$time</td></tr></table>";
echo "<form action=\"ftp.php\" method=\"POST\">
where to download the file to (/home/me/file.txt or c:/file.txt):<br>
<INPUT NAME=\"local\" size=\"40\">
<input type=\"hidden\" name=\"dl\" value=\"1\">
<input type=\"hidden\" name=\"file\" value=\"$file\"><br>
<INPUT TYPE=\"submit\" name=\"get\" VALUE=\"download file\">
</FORM>";
echo "</body></html>";

}

} elseif($rename) {

if($do) {

if(!$val) {
die("please enter a value");
}

ftp_rename($ftp, $rename, $val);
echo funk_die(normal);

} else {

echo "<html><body>
rename this file: $rename
<p>
<form action=\"ftp.php\" method=\"POST\">
Rename to: <input size=\"50\" name=\"val\" value=\"$rename\"><br>
<input type=\"hidden\" name=\"rename\" value=\"$rename\">
<input type=\"submit\" name=\"do\" value=\"rename\">
</form>
</body></html>";

}

} elseif($chmod) {

if($do) {

if(!$val) {
die("please enter a value");
}

$cmd="CHMOD $val $file";
ftp_site($ftp, $cmd);
echo funk_die(normal);

} else {

echo "<html><body>
chmod this file: $thingy
<p>
<form action=\"ftp.php\" method=\"POST\">
<input size=\"4\" name=\"val\" maxlength=\"4\"> CHMOD value<br>
<input type=\"hidden\" name=\"file\" value=\"$thingy\">
<input type=\"hidden\" name=\"chmod\" value=\"1\">
<input type=\"submit\" name=\"do\" value=\"chmod\">
</form>
</body></html>";

}

} elseif($delete) {

if($delete=='file') {
ftp_delete($ftp, $thingy);
} elseif($delete=='dir') {
ftp_rmdir($ftp, $thingy);
}
echo funk_die(normal);

} elseif($upload) {

if(!$localfile) { die("please enter a file"); }

$file = substr( strrchr( $localfile, "/" ), 1 );
$put_thingy = $current_dir . "/" . $file;
print ($put_thingy . "<br />");
print ($localfile . "<br />");

$put = ftp_put($ftp, $put_thingy, $localfile, FTP_BINARY);
if ($put==true)
{
print "file ok<br />";
}
else
{
print "file bad<br />";
}
// echo funk_die(normal);

} elseif($newdir) {

if(!$name) { die("please enter a name"); }

$newdir = $current_dir . "/" . $name;
ftp_mkdir($ftp,$newdir);
echo funk_die(normal);

} elseif($updir) {

$newdir = str_replace( substr( strrchr( $updir, "/" ), 1 ) , "", $updir);

ftp_chdir($ftp,$newdir);
echo dir_funk($username, $password,$ftp);

} else {

echo dir_funk($username, $password,$ftp);

}
}


function funk_die($msg) {
if($msg=='normal') {
return "<html><body><a href=\"ftp.php\">back</a></body></html>";
}
}
?>
[http://www.v7n.com/forums/coding-forum/28632-ftp-login-php-script-website.html]

lcpPhp'PHP-INFO

name::
* McsEngl.lcpPhp'PHP-INFO@cptIt,
* McsEngl.lcpPhp'ex.php-info@cptIt,

<?php
phpinfo();
?>

lcpPhp'set-include-path()

name::
* McsEngl.lcpPhp'set-include-path()@cptIt,
* McsEngl.lcpPhp'get-include-path()@cptIt,

_CODE.PHP:
set_include_path(get_include_path() . PATH_SEPARATOR . 'phpseclib');
>>> adds in the 'path' and the phpseclib directory, so we can 'include' any file from this like it is in the current directory.

lcpPhp'SUGGESTING

name::
* McsEngl.lcpPhp'SUGGESTING@cptIt,
* McsEngl.lcpPhp'doing.Suggesting@cptIt,
* McsEngl.lcpPhp'ex.suggesting@cptIt,

_ADDRESS.WPG:

The HTML Page

When a user types a character in the input field above, the function "showHint()" is executed. The function is triggered by the "onkeyup" event:

<html>
<head>
<script type="text/javascript">
function showHint(str)
{
if (str.length==0)
{
document.getElementById("txtHint").innerHTML="";
return;
}
if (window.XMLHttpRequest)
{// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else
{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.getElementById("txtHint").innerHTML=xmlhttp.responseText;
}
}
xmlhttp.open("GET","gethint.php?q="+str,true);
xmlhttp.send();
}
</script>
</head>
<body>

<p><b>Start typing a name in the input field below:</b></p>
<form>
First name: <input type="text" onkeyup="showHint(this.value)" size="20" />
</form>
<p>Suggestions: <span id="txtHint"></span></p>

</body>
</html>

Source code explanation:

If the input field is empty (str.length==0), the function clears the content of the txtHint placeholder and exits the function.

If the input field is not empty, the showHint() function executes the following:

Create an XMLHttpRequest object
Create the function to be executed when the server response is ready
Send the request off to a file on the server
Notice that a parameter (q) is added to the URL (with the content of the input field)
The PHP File

The page on the server called by the JavaScript above is a PHP file called "gethint.php".

The source code in "gethint.php" checks an array of names, and returns the corresponding name(s) to the browser:

<?php
// Fill up array with names
$a[]="Anna";
$a[]="Brittany";
$a[]="Cinderella";
$a[]="Diana";
$a[]="Eva";
$a[]="Fiona";
$a[]="Gunda";
$a[]="Hege";
$a[]="Inga";
$a[]="Johanna";
$a[]="Kitty";
$a[]="Linda";
$a[]="Nina";
$a[]="Ophelia";
$a[]="Petunia";
$a[]="Amanda";
$a[]="Raquel";
$a[]="Cindy";
$a[]="Doris";
$a[]="Eve";
$a[]="Evita";
$a[]="Sunniva";
$a[]="Tove";
$a[]="Unni";
$a[]="Violet";
$a[]="Liza";
$a[]="Elizabeth";
$a[]="Ellen";
$a[]="Wenche";
$a[]="Vicky";

//get the q parameter from URL
$q=$_GET["q"];

//lookup all hints from array if length of q>0
if (strlen($q) > 0)
{
$hint="";
for($i=0; $i<count($a); $i++)
{
if (strtolower($q)==strtolower(substr($a[$i],0,strlen($q))))
{
if ($hint=="")
{
$hint=$a[$i];
}
else
{
$hint=$hint." , ".$a[$i];
}
}
}
}

// Set output to "no suggestion" if no hint were found
// or to the correct values
if ($hint == "")
{
$response="no suggestion";
}
else
{
$response=$hint;
}

//output the response
echo $response;
?>
Explanation: If there is any text sent from the JavaScript (strlen($q) > 0), the following happens:

Find a name matching the characters sent from the JavaScript
If no match were found, set the response string to "no suggestion"
If one or more matching names were found, set the response string to all these names
The response is sent to the "txtHint" placeholder
[http://www.w3schools.com/php/php_ajax_php.asp]

lcpPhp'operator'precedence

name::
* McsEngl.lcpPhp'operator'precedence@cptIt,

SPECIFIC

* lcpPhp'operator.SPECIFIC,

_SPECIFIC:
here are many operators used in PHP, so we have separated them into the following categories to make it easier to learn them all.
* Assignment Operators
* Arithmetic Operators
* Comparison Operators
* String Operators
* Combination Arithmetic & Assignment Operators
[http://www.tizag.com/phpT/operators.php]
===
Arithmetic Operators
Assignment Operators
Bitwise Operators
Comparison Operators
Error Control Operators
Execution Operators
Incrementing/Decrementing Operators
Logical Operators
String Operators
Array Operators
Type Operators

lcpPhp'operator.ASSINGMENT

name::
* McsEngl.lcpPhp'operator.ASSINGMENT@cptIt,

_DESCRIPTION:
Assignment Operators ¶

The basic assignment operator is "=". Your first inclination might be to think of this as "equal to". Don't. It really means that the left operand gets set to the value of the expression on the right (that is, "gets set to").

The value of an assignment expression is the value assigned. That is, the value of "$a = 3" is 3. This allows you to do some tricky things:

<?php

$a = ($b = 4) + 5; // $a is equal to 9 now, and $b has been set to 4.

?>
For arrays, assigning a value to a named key is performed using the "=>" operator. The precedence of this operator is the same as other assignment operators.

In addition to the basic assignment operator, there are "combined operators" for all of the binary arithmetic, array union and string operators that allow you to use a value in an expression and then set its value to the result of that expression. For example:

<?php

$a = 3;
$a += 5; // sets $a to 8, as if we had said: $a = $a + 5;
$b = "Hello ";
$b .= "There!"; // sets $b to "Hello There!", just like $b = $b . "There!";

?>
Note that the assignment copies the original variable to the new one (assignment by value), so changes to one will not affect the other. This may also have relevance if you need to copy something like a large array inside a tight loop.

An exception to the usual assignment by value behaviour within PHP occurs with objects, which are assigned by reference in PHP 5. Objects may be explicitly copied via the clone keyword.

Assignment by Reference ¶

Assignment by reference is also supported, using the "$var = &$othervar;" syntax. Assignment by reference means that both variables end up pointing at the same data, and nothing is copied anywhere.
[http://www.php.net/manual/en/language.operators.assignment.php]

_TOKEN:
T_AND_EQUAL    &=
T_CONCAT_EQUAL  .=
T_DIV_EQUAL    /=
T_MINUS_EQUAL  -=
T_MOD_EQUAL    %=
T_MUL_EQUAL    *=
T_OR_EQUAL    |=
T_PLUS_EQUAL    +=
T_SL_EQUAL    <<=
T_SR_EQUAL    >>=
T_XOR_EQUAL    ^=
[http://www.php.net/manual/en/tokens.php]

lcpPhp'operator.COMPARISON

name::
* McsEngl.lcpPhp'operator.COMPARISON@cptIt,
* McsEngl.lcpPhp'comparison-operator@cptIt,

_DESCRIPTION:
Comparison Operators ¶
Comparison operators, as their name implies, allow you to compare two values. You may also be interested in viewing the type comparison tables, as they show examples of various type related comparisons.

Comparison Operators
Example  Name  Result
$a == $b  Equal  TRUE if $a is equal to $b after type juggling.
$a === $b  Identical  TRUE if $a is equal to $b, and they are of the same type.
$a != $b  Not equal  TRUE if $a is not equal to $b after type juggling.
$a <> $b  Not equal  TRUE if $a is not equal to $b after type juggling.
$a !== $b  Not identical  TRUE if $a is not equal to $b, or they are not of the same type.
$a < $b  Less than  TRUE if $a is strictly less than $b.
$a > $b  Greater than  TRUE if $a is strictly greater than $b.
$a <= $b  Less than or equal to  TRUE if $a is less than or equal to $b.
$a >= $b  Greater than or equal to  TRUE if $a is greater than or equal to $b.
If you compare a number with a string or the comparison involves numerical strings, then each string is converted to a number and the comparison performed numerically. These rules also apply to the switch statement. The type conversion does not take place when the comparison is === or !== as this involves comparing the type as well as the value.
[http://www.php.net/manual/en/language.operators.comparison.php]

lcpPhp'operator.DOUBLE-COLON (::)

name::
* McsEngl.lcpPhp'operator.DOUBLE-COLON (::)@cptIt,
* McsEngl.lcpPhp'double-colon@cptIt,
* McsEngl.lcpPhp'operator.scope-resolution@cptIt,
* McsEngl.lcpPhp'scope-resolution-operator@cptIt,

_DESCRIPTION:
Scope Resolution Operator (::)

The Scope Resolution Operator (also called Paamayim Nekudotayim) or in simpler terms, the double colon, is a token that allows access to static, constant, and overridden properties or methods of a class.

When referencing these items from outside the class definition, use the name of the class.

As of PHP 5.3.0, it's possible to reference the class using a variable. The variable's value can not be a keyword (e.g. self, parent and static).

Paamayim Nekudotayim would, at first, seem like a strange choice for naming a double-colon. However, while writing the Zend Engine 0.5 (which powers PHP 3), that's what the Zend team decided to call it. It actually does mean double-colon - in Hebrew!

Example#1 :: from outside the class definition
<?php
class MyClass {
const CONST_VALUE = 'A constant value';
}

$classname = 'MyClass';
echo $classname::CONST_VALUE; // As of PHP 5.3.0

echo MyClass::CONST_VALUE;
[http://www.php.net/manual/en/language.oop5.paamayim-nekudotayim.php]

lcpPhp'operator.ERROR-CONTROL

name::
* McsEngl.lcpPhp'operator.ERROR-CONTROL@cptIt,
* McsEngl.lcpPhp'at-sign@cptIt,
* McsEngl.lcpPhp'error-control-operator@cptIt,

_DESCRIPTION:
Error Control Operators
PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any error messages that might be generated by that expression will be ignored.
[http://gr.php.net/manual/en/language.operators.errorcontrol.php]

lcpPhp'operator.LOGICAL

name::
* McsEngl.lcpPhp'operator.LOGICAL@cptIt,
* McsEngl.lcpPhp'logical-operator@cptIt,

_DESCRIPTION:
Example  Name  Result
$a and $b  And  TRUE if both $a and $b are TRUE.
$a or $b  Or  TRUE if either $a or $b is TRUE.
$a xor $b  Xor  TRUE if either $a or $b is TRUE, but not both.
! $a  Not  TRUE if $a is not TRUE.
$a && $b  And  TRUE if both $a and $b are TRUE.
$a || $b  Or  TRUE if either $a or $b is TRUE.
The reason for the two different variations of "and" and "or" operators is that they operate at different precedences. (See Operator Precedence.)
[http://www.php.net/manual/en/language.operators.logical.php]

_TOKEN:
T_BOOLEAN_AND  &&
T_BOOLEAN_OR    ||
T_LOGICAL_AND    and
T_LOGICAL_OR    or
T_LOGICAL_XOR    xor

lcpPhp'TEXT

name::
* McsEngl.lcpPhp'TEXT@cptIt,
* McsEngl.lcpPhp'text-processing@cptIt,

_ADDRESS.WPG:
* http://gr2.php.net/manual/en/refs.basic.text.php,

_SPECIFIC:
* BBCode — Bulletin Board Code
* PCRE — Regular Expressions (Perl-Compatible)
* POSIX Regex — Regular Expression (POSIX Extended)
* ssdeep — ssdeep Fuzzy Hashing
* Strings#ql:php'string#

lcpPhp'code.processing.XML

name::
* McsEngl.lcpPhp'code.processing.XML@cptIt,
* McsEngl.lcpPhp'XML-manipulation@cptIt,
* McsEngl.lcpPhp'XML-processing@cptIt,
* McsEngl.lcpPhp'XML@cptIt,

_ADDRESS.WPG:
* http://gr2.php.net/manual/en/refs.xml.php,

lcpPhp'cURL

name::
* McsEngl.lcpPhp'cURL@cptIt,
* McsEngl.cURL.php@cptIt,

_DESCRIPTION:
PHP supports libcurl, a library created by Daniel Stenberg, that allows you to connect and communicate to many different types of servers with many different types of protocols. libcurl currently supports the http, https, ftp, gopher, telnet, dict, file, and ldap protocols. libcurl also supports HTTPS certificates, HTTP POST, HTTP PUT, FTP uploading (this can also be done with PHP's ftp extension), HTTP form based upload, proxies, cookies, and user+password authentication.

These functions have been added in PHP 4.0.2.
[http://www.php.net/manual/en/intro.curl.php]

_INSTALLATION.WINXP:
Just an additional note for Windows XP installations ...
So ...
1) remove ';' from extension=php_curl.dll in php.ini
2) ensure that ssleay32.dll and libeay32.dll are in Windows/system32.
3) Copy php_curl.dll into Windows\System32 as well.
[http://www.php.net/manual/en/curl.installation.php]

lcpPhp'encrypting

name::
* McsEngl.lcpPhp'encrypting@cptIt,

_ADDRESS.WPG:
* http://stackoverflow.com/questions/10916284/how-to-encrypt-decrypt-data-in-php,

lcpPhp'FTP

name::
* McsEngl.lcpPhp'FTP@cptIt,

_DESCRIPTION:
The functions in this extension implement client access to files servers speaking the File Transfer Protocol (FTP) as defined in » http://www.faqs.org/rfcs/rfc959. This extension is meant for detailed access to an FTP server providing a wide range of control to the executing script. If you only wish to read from or write to a file on an FTP server, consider using the ftp:// wrapper with the filesystem functions which provide a simpler and more intuitive interface.
[http://www.php.net/manual/en/intro.ftp.php]

_CODE.PHP:
<?php

# This function fix problems with ftp login validation

function connect_send_ftp($ftp_server, $ftp_user_name, $ftp_user_pass, $remote_name, $local_name) {
// valid host connection
if (!ftp_connect($ftp_server))
return false;
$conn_id = ftp_connect($ftp_server);

// valid ftp login params, fast check
if(empty($ftp_user_name) or empty($ftp_user_pass))
return false;

// using curl to valid login, fast check
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL,'ftp://'.preg_replace('/^ftp[:]\/\//i','',$ftp_server));
curl_setopt($curl, CURLOPT_FTPLISTONLY, 1);
curl_setopt($curl, CURLOPT_USERPWD, $ftp_user_name.":".$ftp_user_pass);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
$valid_login = curl_exec ($curl);

// valid ftp login, primary
if(!$valid_login)
return false;

// valid ftp login, secondary
if(!ftp_login($conn_id, $ftp_user_name, $ftp_user_pass))
return false;

// passive result
$passive_result = ftp_pasv($conn_id, true);

// save file send erros
$error = ftp_put($conn_id, $remote_name, $local_name, FTP_ASCII);

// close connection
ftp_close($conn_id);

// return success or send erros
return $error;
}

// set params
$ftp_server = "ftp.example.com"
$ftp_user_name = "user";
$ftp_user_pass = "password";
$remote_name = "my_remote_file_dir";
$local_name = "my_local_file_dir";

// call the function
$conn = connect_send_ftp($ftp_server, $ftp_user_name, $ftp_user_pass, $remote_name, $local_name);

// valid response
if(!$conn)
die("FTP login failed..")

// if not erros, success
echo "FTP login and file sended sucessfull!"

?>
[http://www.php.net/manual/en/function.ftp-login.php]
===
<?php
// set up basic connection
$conn_id = ftp_connect($ftp_server);

// login with username and password
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);

// check connection
if ((!$conn_id) || (!$login_result)) {
echo "FTP connection has failed!";
echo "Attempted to connect to $ftp_server for user $ftp_user_name";
exit;
} else {
echo "Connected to $ftp_server, for user $ftp_user_name";
}

// upload the file
$upload = ftp_put($conn_id, $destination_file, $source_file, FTP_BINARY);

// check upload status
if (!$upload) {
echo "FTP upload has failed!";
} else {
echo "Uploaded $source_file to $ftp_server as $destination_file";
}

// close the FTP stream
ftp_close($conn_id);
?>
[http://www.php.net/manual/en/ftp.examples-basic.php]
===
<?php

// set up basic connection
$conn_id = ftp_connect($ftp_server);

// login with username and password
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);

// print the current directory
echo ftp_pwd($conn_id); // /

// close this connection
ftp_close($conn_id);
?>
[http://php.net/manual/en/function.ftp-close.php]

lcpPhp'phpseclib

name::
* McsEngl.lcpPhp'phpseclib@cptIt,
* McsEngl.phpseclib@cptIt,

_ADDRESS.WPG:
* https://github.com/phpseclib/phpseclib,
* doc: http://phpseclib.sourceforge.net/documentation//
* support: http://www.frostjedi.com/phpbb3/viewforum.php?f=46,

_DESCRIPTION:
Compatibility

phpseclib is designed to be ultra-compatible. It works on PHP4+ (PHP4, assuming the use of PHP_Compat) and doesn't require any extensions. For purposes of speed, mcrypt is used if it's available as is gmp or bcmath (in that order), but they are not required.

Interoperability

phpseclib is designed to be fully interoperable with OpenSSL and other standardized cryptography programs and protocols.

MIT-Licensed

phpseclib is licensed with the MIT-license. By virtue of not being copyleft it's less restrictive than the GPL, which in turn, means that it's fully GPL compatible.

Usage

This library is written using the same conventions that libraries in the PHP Extension and Application Repository (PEAR) used to be written in (current requirements break PHP4 compatibility). In particular, this library needs to be in your include_path:

<?php
set_include_path(get_include_path() . PATH_SEPARATOR . 'phpseclib');

include('Net/SSH2.lcpPhp');
?>
[http://phpseclib.sourceforge.net/]

lcpPhp'ssh2

name::
* McsEngl.lcpPhp'ssh2@cptIt,

Bindings to the » libssh2 library which provide access to resources (shell, remote exec, tunneling, file transfer) on a remote machine using a secure cryptographic transport.
[http://www.php.net/manual/en/intro.ssh2.php]

lcpPhp'MySQL

name::
* McsEngl.lcpPhp'MySQL@cptIt,

lcpPhp'PostgreSQL

name::
* McsEngl.lcpPhp'PostgreSQL@cptIt,

phppgm'file-code

name::
* McsEngl.phppgm'file-code@cptIt,

Note: The file must have a .php extension. If the file has a .html extension, the PHP code will not be executed.
[http://www.w3schools.com/php/php_syntax.asp]

First off, note that simPHP stats can only be displayed on PHP-enabled webpages (with .php ext).
[https://code.google.com/p/simphp/wiki/README]

phppgm'developing

name::
* McsEngl.phppgm'developing@cptIt,

phppgm'run-locally

name::
* McsEngl.phppgm'run-locally@cptIt,

Put the directory of the code on \public_html\dir\
run on browser: localhost/dir/

phppgm'tag

name::
* McsEngl.phppgm'tag@cptIt,
* McsEngl.lcpPhp'tag@cptIt,

_DESCRIPTION:
When PHP parses a file, it looks for opening and closing tags, which are <?php and ?> which tell PHP to start and stop interpreting the code between them. Parsing in this manner allows PHP to be embedded in all sorts of different documents, as everything outside of a pair of opening and closing tags is ignored by the PHP parser.

PHP also allows for short tags <? and ?> (which are discouraged because they are only available if enabled with short_open_tag php.ini configuration file directive, or if PHP was configured with the --enable-short-tags option.

If a file is pure PHP code, it is preferable to omit the PHP closing tag at the end of the file. This prevents accidental whitespace or new lines being added after the PHP closing tag, which may cause unwanted effects because PHP will start output buffering when there is no intention from the programmer to send any output at that point in the script.
[http://www.php.net/manual/en/language.basic-syntax.phptags.php]

phppgm.HELLO-WORLD

name::
* McsEngl.phppgm.HELLO-WORLD@cptIt,
* McsEngl.lcpPhp'ex.hello-world@cptIt,

_CODE.PHP: echo
file: hello.php: put on php-server and access it:
<html>
<head>
<title>PHP Test</title>
</head>
<body>
<?php echo '<p>Hello World</p>'; ?>
</body>
</html>

lcpPhp'statement.SPECIFIC

name::
* McsEngl.lcpPhp'statement.SPECIFIC@cptIt,

_Alphabetically:
* composite
* compositeNo

lcpPhp'statetement'Separation

name::
* McsEngl.lcpPhp'statetement'Separation@cptIt,

As in C or Perl, PHP requires instructions to be terminated with a semicolon at the end of each statement. The closing tag of a block of PHP code automatically implies a semicolon; you do not need to have a semicolon terminating the last line of a PHP block. The closing tag for the block will include the immediately trailing newline if one is present.
[http://www.php.net/manual/en/language.basic-syntax.instruction-separation.php]

lcpPhp'statement.SPECIFIC

name::
* McsEngl.lcpPhp'statement.SPECIFIC@cptIt,

_SPECIFIC:
* new-statement#ql:php'object'creating#

lcpPhp'statement.

name::
* McsEngl.lcpPhp'statement.@cptIt,
* McsEngl.lcpPhp'-statement@cptIt,

lcpPhp'statement.assignment

name::
* McsEngl.lcpPhp'statement.assignment@cptIt,
* McsEngl.lcpPhp'assignment-statement@cptIt,

lcpPhp'statement.Composite

name::
* McsEngl.lcpPhp'statement.Composite@cptIt,
* McsEngl.lcpPhp'composite-statement@cptIt,
* McsEngl.lcpPhp'group-statement@cptIt,

lcpPhp'statement.CompositeNo

name::
* McsEngl.lcpPhp'statement.CompositeNo@cptIt,
* McsEngl.lcpPhp'compositeNo-statement@cptIt,

lcpPhp'statement.control

name::
* McsEngl.lcpPhp'statement.control@cptIt,
* McsEngl.lcpPhp'control-statement@cptIt,

lcpPhp'statement.decleare

name::
* McsEngl.lcpPhp'statement.decleare@cptIt,
* McsEngl.lcpPhp'decleare-statement@cptIt,

_DESCRIPTION:
The declare construct is used to set execution directives for a block of code. The syntax of declare is similar to the syntax of other flow control constructs:

declare (directive)
statement
The directive section allows the behavior of the declare block to be set. Currently only two directives are recognized: the ticks directive (See below for more information on the ticks directive) and the encoding directive (See below for more information on the encoding directive).
[http://www.php.net/manual/en/control-structures.declare.php]

<?php
declare(encoding='ISO-8859-1');
// code here
?>

lcpPhp'statement.echo

name::
* McsEngl.lcpPhp'statement.echo@cptIt,
* McsEngl.lcpPhp'echo@cptIt,
* McsEngl.lcpPhp'ex.echo@cptIt,

_CODE.PHP:
<?php
$txt="Hello World";
echo $txt;
?>

lcpPhp'statement.empty

name::
* McsEngl.lcpPhp'statement.empty@cptIt,
* McsEngl.lcpPhp'empty-statement@cptIt,

lcpPhp'statement.function-call

name::
* McsEngl.lcpPhp'statement.function-call@cptIt,
* McsEngl.lcpPhp'function-call-statement@cptIt,

lcpPhp'statement.goto

name::
* McsEngl.lcpPhp'statement.goto@cptIt,
* McsEngl.lcpPhp'goto-statement@cptIt,

_DESCRIPTION:
goto

The goto operator can be used to jump to another section in the program. The target point is specified by a label followed by a colon, and the instruction is given as goto followed by the desired target label. This is not a full unrestricted goto. The target label must be within the same file and context, meaning that you cannot jump out of a function or method, nor can you jump into one. You also cannot jump into any sort of loop or switch structure. You may jump out of these, and a common use is to use a goto in place of a multi-level break.

Example#1 goto example
<?php
goto a;
echo 'Foo';

a:
echo 'Bar';
?>
The above example will output:
Bar

lcpPhp'statement.if

name::
* McsEngl.lcpPhp'statement.if@cptIt,
* McsEngl.lcpPhp'if-statement@cptIt,

_DESCRIPTION:
The if construct is one of the most important features of many languages, PHP included. It allows for conditional execution of code fragments. PHP features an if structure that is similar to that of C:

if (expr)
statement
[http://www.php.net/manual/en/control-structures.if.php]

Alternative syntax for control structures

PHP offers an alternative syntax for some of its control structures; namely, if, while, for, foreach, and switch. In each case, the basic form of the alternate syntax is to change the opening brace to a colon (:) and the closing brace to endif;, endwhile;, endfor;, endforeach;, or endswitch;, respectively.

<?php if ($a == 5): ?>
A is equal to 5
<?php endif; ?>
In the above example, the HTML block "A is equal to 5" is nested within an if statement written in the alternative syntax. The HTML block would be displayed only if $a is equal to 5.

The alternative syntax applies to else and elseif as well. The following is an if structure with elseif and else in the alternative format:

<?php
if ($a == 5):
echo "a equals 5";
echo "...";
elseif ($a == 6):
echo "a equals 6";
echo "!!!";
else:
echo "a is neither 5 nor 6";
endif;
?>
Note:

Mixing syntaxes in the same control block is not supported.
[http://www.php.net/manual/en/control-structures.alternative-syntax.php]

lcpPhp'statement.include

name::
* McsEngl.lcpPhp'statement.include@cptIt,
* McsEngl.lcpPhp'include-statement@cptIt,

_CODE.PHP:
include('Net/SSH2.lcpPhp');
===

vars.php
<?php

$color = 'green';
$fruit = 'apple';

?>
===
test.php
<?php

echo "A $color $fruit"; // A

include 'vars.lcpPhp';

echo "A $color $fruit"; // A green apple

?>

===

menu.php:
<html>
<body>
<a href="http://www.example.com/index.php">Home</a> -
<a href="http://www.example.com/about.php">About Us</a> -
<a href="http://www.example.com/links.php">Links</a> -
<a href="http://www.example.com/contact.php">Contact Us</a> <br />
Save the above file as "menu.php". Now create a new file, "index.php" in the same directory as "menu.php". Here we will take advantage of the include command to add our common menu.

index.php Code:
<?php include("menu.php"); ?>
<p>This is my home page that uses a common menu to save me time when I add
new pages to my website!</p>
</body>
</html>

Display:
Home - About Us - Links - Contact Us
This is my home page that uses a common menu to save me time when I add new pages to my website!
[http://www.tizag.com/phpT/include.php]

lcpPhp'statement.loop

name::
* McsEngl.lcpPhp'statement.loop@cptIt,
* McsEngl.lcpPhp'loop-statement@cptIt,

_SPECIFIC:
* do-while
* for
* foreach
* while

lcpPhp'statement.return

name::
* McsEngl.lcpPhp'statement.return@cptIt,
* McsEngl.lcpPhp'return-statement@cptIt,

_DESCRIPTION:
If called from within a function, the return() statement immediately ends execution of the current function, and returns its argument as the value of the function call. return() will also end the execution of an eval() statement or script file.

If called from the global scope, then execution of the current script file is ended. If the current script file was include()ed or require()ed, then control is passed back to the calling file. Furthermore, if the current script file was include()ed, then the value given to return() will be returned as the value of the include() call. If return() is called from within the main script file, then script execution ends. If the current script file was named by the auto_prepend_file or auto_append_file configuration options in php.ini, then that script file's execution is ended.
[http://www.php.net/manual/en/function.return.php]

lcpPhp'code.COMMENT

name::
* McsEngl.lcpPhp'code.COMMENT@cptIt,
* McsEngl.lcpPhp'code.COMMENT@cptIt,
* McsEngl.lcpPhp'comment@cptIt,

_PART:
* program#ql:php'program#

_GENERIC:
* lcp-comment#ql:lcp'comment@cptIt#
* unit-of-code#ql:"php'unit_of_code"#, {2012-01-22}

_line_comment:
// ....
# This is also a single line comment

_multiline_comment:
/* ... */

lcpPhp'delimeter

name::
* McsEngl.lcpPhp'delimeter@cptIt,

lcpPhp'Keyword

name::
* McsEngl.lcpPhp'Keyword@cptIt,
* McsEngl.lcpPhp'reserved-word@cptIt,

PHP Keywords
* lcpPhp'keyword.abstract (as of PHP 5)  
* lcpPhp'keyword.and  
* lcpPhp'keyword.array()  
* lcpPhp'keyword.as  

* lcpPhp'keyword.break

* lcpPhp'keyword.case  
* lcpPhp'keyword.catch (as of PHP 5)  
* lcpPhp'keyword.cfunction (PHP 4 only)  
* lcpPhp'keyword.class  
* lcpPhp'keyword.clone (as of PHP 5)
* lcpPhp'keyword.const  
* lcpPhp'keyword.continue  

* lcpPhp'keyword.declare  
* lcpPhp'keyword.default  
* lcpPhp'keyword.do

* lcpPhp'keyword.else  
* lcpPhp'keyword.elseif  
* lcpPhp'keyword.enddeclare  
* lcpPhp'keyword.endfor  
* lcpPhp'keyword.endforeach
* lcpPhp'keyword.endif  
* lcpPhp'keyword.endswitch  
* lcpPhp'keyword.endwhile  
* lcpPhp'keyword.extends  

* lcpPhp'keyword.final (as of PHP 5)
* lcpPhp'keyword.for  
* lcpPhp'keyword.foreach  
* lcpPhp'keyword.function  

* lcpPhp'keyword.global  
* lcpPhp'keyword.goto (as of PHP 5.3)

* lcpPhp'keyword.if  
* lcpPhp'keyword.implements (as of PHP 5)  
* lcpPhp'keyword.interface (as of PHP 5)  
* lcpPhp'keyword.instanceof (as of PHP 5)

* lcpPhp'keyword.namespace (as of PHP 5.3)  
* lcpPhp'keyword.new  

* lcpPhp'keyword.old_function (PHP 4 only)  
* lcpPhp'keyword.or  

* lcpPhp'keyword.private (as of PHP 5)
* lcpPhp'keyword.protected (as of PHP 5)  
* lcpPhp'keyword.public (as of PHP 5)  

* lcpPhp'keyword.static  
* lcpPhp'keyword.switch  

* lcpPhp'keyword.throw (as of PHP 5)
* lcpPhp'keyword.try (as of PHP 5)  

* lcpPhp'keyword.use  

* lcpPhp'keyword.var  

* lcpPhp'keyword.while  

* lcpPhp'keyword.xor
[http://www.php.net/manual/en/reserved.keywords.php]

lcpPhp'Token

name::
* McsEngl.lcpPhp'Token@cptIt,

_DESCRIPTION:
The analysis stage can be broken down into three sub-parts: lexical analysis, syntax analysis, and semantic analysis. The first stage reads the input script character by character to find tokens - parts of the script that are logical units by themselves. In PHP terms, a string is a token, as is a variable, a number, a brace, etc. As the lexical analyser (usually just called the lexer) finds tokens within a script, it returns them to the syntax analyser (parser), which makes sure that the script fits the syntax rules you have laid down. Finally, once the script has been tokenised and parsed, the semantic analyser kicks in to make sure the meaning of the script is valid.
[http://tuxradar.com/practicalphp/21/5/3]

_SPECIFIC:
Token,, Syntax,, Reference
* lcpPhp'token.T_ABSTRACT,, abstract,, Class Abstraction (available since PHP 5.0.0)
* lcpPhp'token.T_AND_EQUAL,, &=,, assignment operators
* lcpPhp'token.T_ARRAY,, array(),, array(), array syntax
* lcpPhp'token.T_ARRAY_CAST,, (array),, type-casting
* lcpPhp'token.T_AS,, as,, foreach
* lcpPhp'token.T_BAD_CHARACTER,, ,, anything below ASCII 32 except \t (0x09), \n (0x0a) and \r (0x0d)
* lcpPhp'token.T_BOOLEAN_AND,, &&,, logical operators
* lcpPhp'token.T_BOOLEAN_OR,, ||,, logical operators
* lcpPhp'token.T_BOOL_CAST,, (bool) or (boolean),, type-casting
* lcpPhp'token.T_BREAK,, break,, break
* lcpPhp'token.T_CALLABLE,, callable,, callable
* lcpPhp'token.T_CASE,, case,, switch
* lcpPhp'token.T_CATCH,, catch,, Exceptions (available since PHP 5.0.0)
* lcpPhp'token.T_CHARACTER,, ,, not used anymore
* lcpPhp'token.T_CLASS,, class,, classes and objects
* lcpPhp'token.T_CLASS_C,, __CLASS__,, magic constants (available since PHP 4.3.0)
* lcpPhp'token.T_CLONE,, clone,, classes and objects (available since PHP 5.0.0)
* lcpPhp'token.T_CLOSE_TAG,, ?> or %>,, escaping from HTML
* lcpPhp'token.T_COMMENT,, // or#, and /* */ in PHP 5,, comments
* lcpPhp'token.T_CONCAT_EQUAL,, .=,, assignment operators
* lcpPhp'token.T_CONST,, const,, class constants
* lcpPhp'token.T_CONSTANT_ENCAPSED_STRING,, "foo" or 'bar',, string syntax
* lcpPhp'token.T_CONTINUE,, continue,, continue
* lcpPhp'token.T_CURLY_OPEN,, {$,, complex variable parsed syntax
* lcpPhp'token.T_DEC,, --,, incrementing/decrementing operators
* lcpPhp'token.T_DECLARE,, declare,, declare
* lcpPhp'token.T_DEFAULT,, default,, switch
* lcpPhp'token.T_DIR,, __DIR__,, magic constants (available since PHP 5.3.0)
* lcpPhp'token.T_DIV_EQUAL,, /=,, assignment operators
* lcpPhp'token.T_DNUMBER,, 0.12, etc,, floating point numbers
* lcpPhp'token.T_DOC_COMMENT,, /** */,, PHPDoc style comments (available since PHP 5.0.0)
* lcpPhp'token.T_DO,, do,, do..while
* lcpPhp'token.T_DOLLAR_OPEN_CURLY_BRACES,, ${,, complex variable parsed syntax
* lcpPhp'token.T_DOUBLE_ARROW,, =>,, array syntax
* lcpPhp'token.T_DOUBLE_CAST,, (real), (double) or (float),, type-casting
* lcpPhp'token.T_DOUBLE_COLON,, ::,, see T_PAAMAYIM_NEKUDOTAYIM below
* lcpPhp'token.T_ECHO,, echo,, echo
* lcpPhp'token.T_ELSE,, else,, else
* lcpPhp'token.T_ELSEIF,, elseif,, elseif
* lcpPhp'token.T_EMPTY,, empty,, empty()
* lcpPhp'token.T_ENCAPSED_AND_WHITESPACE,, " $a",, constant part of string with variables
* lcpPhp'token.T_ENDDECLARE,, enddeclare,, declare, alternative syntax
* lcpPhp'token.T_ENDFOR,, endfor,, for, alternative syntax
* lcpPhp'token.T_ENDFOREACH,, endforeach,, foreach, alternative syntax
* lcpPhp'token.T_ENDIF,, endif,, if, alternative syntax
* lcpPhp'token.T_ENDSWITCH,, endswitch,, switch, alternative syntax
* lcpPhp'token.T_ENDWHILE,, endwhile,, while, alternative syntax
* lcpPhp'token.T_END_HEREDOC,, ,, heredoc syntax
* lcpPhp'token.T_EVAL,, eval(),, eval()
* lcpPhp'token.T_EXIT,, exit or die,, exit(), die()
* lcpPhp'token.T_EXTENDS,, extends,, extends, classes and objects
* lcpPhp'token.T_FILE,, __FILE__,, magic constants
* lcpPhp'token.T_FINAL,, final,, Final Keyword (available since PHP 5.0.0)
* lcpPhp'token.T_FINALLY,, finally,, Exceptions (available since PHP 5.5.0)
* lcpPhp'token.T_FOR,, for,, for
* lcpPhp'token.T_FOREACH,, foreach,, foreach
* lcpPhp'token.T_FUNCTION,, function or cfunction,, functions
* lcpPhp'token.T_FUNC_C,, __FUNCTION__,, magic constants (available since PHP 4.3.0)
* lcpPhp'token.T_GLOBAL,, global,, variable scope
* lcpPhp'token.T_GOTO,, goto,, (available since PHP 5.3.0)
* lcpPhp'token.T_HALT_COMPILER,, __halt_compiler(),, __halt_compiler (available since PHP 5.1.0)
* lcpPhp'token.T_IF,, if,, if
* lcpPhp'token.T_IMPLEMENTS,, implements,, Object Interfaces (available since PHP 5.0.0)
* lcpPhp'token.T_INC,, ++,, incrementing/decrementing operators
* lcpPhp'token.T_INCLUDE,, include(),, include
* lcpPhp'token.T_INCLUDE_ONCE,, include_once(),, include_once
* lcpPhp'token.T_INLINE_HTML,, ,, text outside PHP
* lcpPhp'token.T_INSTANCEOF,, instanceof,, type operators (available since PHP 5.0.0)
* lcpPhp'token.T_INSTEADOF,, insteadof,, Traits (available since PHP 5.4.0)
* lcpPhp'token.T_INT_CAST,, (int) or (integer),, type-casting
* lcpPhp'token.T_INTERFACE,, interface,, Object Interfaces (available since PHP 5.0.0)
* lcpPhp'token.T_ISSET,, isset(),, isset()
* lcpPhp'token.T_IS_EQUAL,, ==,, comparison operators
* lcpPhp'token.T_IS_GREATER_OR_EQUAL,, >=,, comparison operators
* lcpPhp'token.T_IS_IDENTICAL,, ===,, comparison operators
* lcpPhp'token.T_IS_NOT_EQUAL,, != or <>,, comparison operators
* lcpPhp'token.T_IS_NOT_IDENTICAL,, !==,, comparison operators
* lcpPhp'token.T_IS_SMALLER_OR_EQUAL,, <=,, comparison operators
* lcpPhp'token.T_LINE,, __LINE__,, magic constants
* lcpPhp'token.T_LIST,, list(),, list()
* lcpPhp'token.T_LNUMBER,, 123, 012, 0x1ac, etc,, integers
* lcpPhp'token.T_LOGICAL_AND,, and,, logical operators
* lcpPhp'token.T_LOGICAL_OR,, or,, logical operators
* lcpPhp'token.T_LOGICAL_XOR,, xor,, logical operators
* lcpPhp'token.T_METHOD_C,, __METHOD__,, magic constants (available since PHP 5.0.0)
* lcpPhp'token.T_MINUS_EQUAL,, -=,, assignment operators
* lcpPhp'token.T_ML_COMMENT,, /* and */,, comments (PHP 4 only)
* lcpPhp'token.T_MOD_EQUAL,, %=,, assignment operators
* lcpPhp'token.T_MUL_EQUAL,, *=,, assignment operators
* lcpPhp'token.T_NAMESPACE,, namespace,, namespaces (available since PHP 5.3.0)
* lcpPhp'token.T_NS_C,, __NAMESPACE__,, namespaces (available since PHP 5.3.0)
* lcpPhp'token.T_NS_SEPARATOR,, \,, namespaces (available since PHP 5.3.0)
* lcpPhp'token.T_NEW,, new,, classes and objects
* lcpPhp'token.T_NUM_STRING,, "$a[0]",, numeric array index inside string
* lcpPhp'token.T_OBJECT_CAST,, (object),, type-casting
* lcpPhp'token.T_OBJECT_OPERATOR,, ->,, classes and objects
* lcpPhp'token.T_OLD_FUNCTION,, old_function,, (PHP 4 only)
* lcpPhp'token.T_OPEN_TAG,, <?php, <? or <%,, escaping from HTML
* lcpPhp'token.T_OPEN_TAG_WITH_ECHO,, <?= or <%=,, escaping from HTML
* lcpPhp'token.T_OR_EQUAL,, |=,, assignment operators
* lcpPhp'token.T_PAAMAYIM_NEKUDOTAYIM,, ::,, ::. Also defined as T_DOUBLE_COLON.
* lcpPhp'token.T_PLUS_EQUAL,, +=,, assignment operators
* lcpPhp'token.T_PRINT,, print(),, print
* lcpPhp'token.T_PRIVATE,, private,, classes and objects (available since PHP 5.0.0)
* lcpPhp'token.T_PUBLIC,, public,, classes and objects (available since PHP 5.0.0)
* lcpPhp'token.T_PROTECTED,, protected,, classes and objects (available since PHP 5.0.0)
* lcpPhp'token.T_REQUIRE,, require(),, require
* lcpPhp'token.T_REQUIRE_ONCE,, require_once(),, require_once
* lcpPhp'token.T_RETURN,, return,, returning values
* lcpPhp'token.T_SL,, <<,, bitwise operators
* lcpPhp'token.T_SL_EQUAL,, <<=,, assignment operators
* lcpPhp'token.T_SR,, >>,, bitwise operators
* lcpPhp'token.T_SR_EQUAL,, >>=,, assignment operators
* lcpPhp'token.T_START_HEREDOC,, <<<,, heredoc syntax
* lcpPhp'token.T_STATIC,, static,, variable scope
* lcpPhp'token.T_STRING,, parent, true etc.,, identifiers, e.g. keywords like parent and self, function names, class names and more are matched. See also T_CONSTANT_ENCAPSED_STRING.
* lcpPhp'token.T_STRING_CAST,, (string),, type-casting
* lcpPhp'token.T_STRING_VARNAME,, "${a,, complex variable parsed syntax
* lcpPhp'token.T_SWITCH,, switch,, switch
* lcpPhp'token.T_THROW,, throw,, Exceptions (available since PHP 5.0.0)
* lcpPhp'token.T_TRAIT,, trait,, Traits (available since PHP 5.4.0)
* lcpPhp'token.T_TRAIT_C,, __TRAIT__,, __TRAIT__ (available since PHP 5.4.0)
* lcpPhp'token.T_TRY,, try,, Exceptions (available since PHP 5.0.0)
* lcpPhp'token.T_UNSET,, unset(),, unset()
* lcpPhp'token.T_UNSET_CAST,, (unset),, type-casting (available since PHP 5.0.0)
* lcpPhp'token.T_USE,, use,, namespaces (available since PHP 5.3.0; reserved since PHP 4.0.0)
* lcpPhp'token.T_VAR,, var,, classes and objects
* lcpPhp'token.T_VARIABLE,, $foo,, variables
* lcpPhp'token.T_WHILE,, while,, while, do..while
* lcpPhp'token.T_WHITESPACE,, \t \r\n,,
* lcpPhp'token.T_XOR_EQUAL,, ^=,, assignment operators
* lcpPhp'token.T_YIELD,, yield,, generators (available since PHP 5.5.0)
[http://www.php.net/manual/en/tokens.php]

SPECIFIC

_SPECIFIC:
* alphabet##
* char##

lcpPhp'alphabet

name::
* McsEngl.lcpPhp'alphabet@cptIt,

!

@

#

$ = variable name.

%

lcpPhp'ampersand_char (&):
To have an argument to a function always passed by reference, prepend an ampersand (&) to the argument name in the function definition:

lcpPhp'configuration

name::
* McsEngl.lcpPhp'configuration@cptIt,

Changing the php.ini, must restart the server.

lcpPhp'grammar

name::
* McsEngl.lcpPhp'grammar@cptIt,

_ADDRESS.WPG:
* http://stackoverflow.com/questions/8931326/ebnf-grammar-definitions-for-php,

lcpPhp'implementation

name::
* McsEngl.lcpPhp'implementation@cptIt,

The PHP language was originally implemented as an interpreter. Several compilers have been developed which decouple the PHP language from the interpreter. Advantages of compilation include better execution speed, obfuscation, static analysis, and improved interoperability with code written in other languages.[79] PHP compilers of note include Phalanger, which compiles PHP into CIL byte-code, and HipHop, developed at Facebook and now available as open source, which transforms the PHP Script into C++, then compiles it, reducing server load up to 50%.
[http://en.wikipedia.org/wiki/Php]

lcpPhp'Installation

name::
* McsEngl.lcpPhp'Installation@cptIt,

Manual:
* unzip file
* configure ini.

lcpPhp'Lexical-analysis

name::
* McsEngl.lcpPhp'Lexical-analysis@cptIt,

The analysis stage can be broken down into three sub-parts: lexical analysis, syntax analysis, and semantic analysis.
The first stage reads the input script character by character to find tokens - parts of the script that are logical units by themselves. In PHP terms, a string is a token, as is a variable, a number, a brace, etc.
As the lexical analyser (usually just called the lexer) finds tokens within a script, it returns them to the syntax analyser (parser), which makes sure that the script fits the syntax rules you have laid down.
Finally, once the script has been tokenised and parsed, the semantic analyser kicks in to make sure the meaning of the script is valid.
[http://tuxradar.com/practicalphp/21/5/3]

lcpPhp'specification

name::
* McsEngl.lcpPhp'specification@cptIt,

_DESCRIPTION:
From what I read on Wikipedia, both PHP and Perl5 have in common that they are "languages" which are entirely defined through one single implementation. The language is precisely whatever the interpreter does. Neither are like C or C++ or Java or ECMAScript, which are standardised languages with many different implementations. (Apparently Perl6 will be different and actually have a specification. No idea of PHP will also one day make this step.)
[http://stackoverflow.com/a/4793261]

lcpPhp'extension'installing

name::
* McsEngl.lcpPhp'extension'installing@cptIt,

Installing a PHP extension on Windows

On Windows, you have two ways to load a PHP extension: either compile it into PHP, or load the DLL. Loading a pre-compiled extension is the easiest and preferred way.

To load an extension, you need to have it available as a ".dll" file on your system. All the extensions are automatically and periodically compiled by the PHP Group (see next section for the download).
[http://www.php.net/manual/en/install.pecl.windows.php]

lcpPhp'extension.PEAR

name::
* McsEngl.lcpPhp'extension.PEAR@cptIt,
* McsEngl.PEAR@cptIt,

_DESCRIPTION:
What is PEAR?
PEAR is short for "PHP Extension and Application Repository" and is pronounced just like the fruit. The purpose of PEAR is to provide:

A structured library of open-source code for PHP users
A system for code distribution and package maintenance
A standard style for code written in PHP, specified here
The PHP Extension Community Library (PECL), see more below
A web site, mailing lists and download mirrors to support the PHP/PEAR community
PEAR is a community-driven project governed by its developers. PEAR's governing bodies are subdivided into the PEAR Group, Collectives, and a President. PEAR's constitution (adopted in March 2007) defining these groups is documented here. The PEAR project was founded in 1999 by Stig S. Bakken and quite a lot of people have joined the project.
[http://pear.php.net/manual/en/about.pear.php]

lcpPhp'extension.PECL

name::
* McsEngl.lcpPhp'extension.PECL@cptIt,
* McsEngl.PECL@cptIt585i,
* McsEngl.PHP-Extension-Community-Library@cptIt,
* McsEngl.lcpPhp'PECL@cptIt,

_ADDRESS.WPG:
* http://php.net/manual/en/install.pecl.php,

_DESCRIPTION:
PECL is a repository for PHP Extensions, providing a directory of all known extensions and hosting facilities for downloading and development of PHP extensions.
The packaging and distribution system used by PECL is shared with its sister, PEAR.
[http://pecl.php.net/index.php]

lcpPhp'extension.Lua

name::
* McsEngl.lcpPhp'extension.Lua@cptIt,
* McsEngl.lua-php-interpreter@cptIt585,

Embedded lua interpreter

_ADDRESS.WPG:
* http://pecl.php.net/package/lua,

lcpPhp'ns'Creating

name::
* McsEngl.lcpPhp'ns'Creating@cptIt,

Namespaces are declared using the namespace keyword. A file containing a namespace must declare the namespace at the top of the file before any other code - with one exception: the declare keyword.

Example#1 Declaring a single namespace
<?php
namespace MyProject;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }

?>
...
In addition, unlike any other PHP construct, the same namespace may be defined in multiple files, allowing splitting up of a namespace's contents across the filesystem.
[http://gr.php.net/manual/en/language.namespaces.definition.php]

lcpPhp'ns'Type-affecting

name::
* McsEngl.lcpPhp'ns'Type-affecting@cptIt,

Although any valid PHP code can be contained within a namespace, only four types of code are affected by namespaces: classes, interfaces, functions and constants.
[http://gr.php.net/manual/en/language.namespaces.definition.php]

lcpPhp'ns.Global

name::
* McsEngl.lcpPhp'ns.Global@cptIt,
* McsEngl.lcpPhp'global-space@cptIt,
* McsEngl.lcpPhp'ns.Unnamespaced-code@cptIt,

To combine global non-namespaced code with namespaced code, only bracketed syntax is supported. Global code should be encased in a namespace statement with no namespace name as in:

Example#3 Declaring multiple namespaces and unnamespaced code
<?php
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
}

namespace { // global code
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>
No PHP code may exist outside of the namespace brackets except for an opening declare statement.

Example#4 Declaring multiple namespaces and unnamespaced code
<?php
declare(encoding='UTF-8');
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
}

namespace { // global code
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>
[http://gr.php.net/manual/en/language.namespaces.definitionmultiple.php]

lcpPhp'ns.SubNamespace

name::
* McsEngl.lcpPhp'ns.SubNamespace@cptIt,

Declaring sub-namespaces

(PHP 5 >= 5.3.0)

Much like directories and files, PHP namespaces also contain the ability to specify a hierarchy of namespace names. Thus, a namespace name can be defined with sub-levels:

Example#1 Declaring a single namespace with hierarchy
<?php
namespace MyProject\Sub\Level;

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }

?>
The above example creates constant MyProject\Sub\Level\CONNECT_OK, class MyProject\Sub\Level\Connection and function MyProject\Sub\Level\connect.
[http://gr.php.net/manual/en/language.namespaces.nested.php]

lcpPhp'security'accessing-any-web-document-on-server

name::
* McsEngl.lcpPhp'security'accessing-any-web-document-on-server@cptIt,

Accessing any web document on server: http://my.host/cgi-bin/php/secret/doc.html The path information part of the URL after the PHP binary name, /secret/doc.html is conventionally used to specify the name of the file to be opened and interpreted by the CGI program. Usually some web server configuration directives (Apache: Action) are used to redirect requests to documents like http://my.host/secret/script.php to the PHP interpreter. With this setup, the web server first checks the access permissions to the directory /secret, and after that creates the redirected request http://my.host/cgi-bin/php/secret/script.php. Unfortunately, if the request is originally given in this form, no access checks are made by web server for file /secret/script.php, but only for the /cgi-bin/php file. This way any user able to access /cgi-bin/php is able to access any protected document on the web server. In PHP, runtime configuration directives cgi.force_redirect, doc_root and user_dir can be used to prevent this attack, if the server document tree has any directories with access restrictions. See below for full the explanation of the different combinations.
[http://www.php.net/manual/en/security.cgi-bin.attacks.php]

lcpPhp'security'code

name::
* McsEngl.lcpPhp'security'code@cptIt,
* McsEngl.lcpPhp'code.SECURITY@cptIt,

lcpPhp'security'database

name::
* McsEngl.lcpPhp'security'database@cptIt,

Nowadays, databases are cardinal components of any web based application by enabling websites to provide varying dynamic content. Since very sensitive or secret information can be stored in a database, you should strongly consider protecting your databases.

To retrieve or to store any information you need to connect to the database, send a legitimate query, fetch the result, and close the connection. Nowadays, the commonly used query language in this interaction is the Structured Query Language (SQL). See how an attacker can tamper with an SQL query.

As you can surmise, PHP cannot protect your database by itself. The following sections aim to be an introduction into the very basics of how to access and manipulate databases within PHP scripts.

Keep in mind this simple rule: defense in depth. The more places you take action to increase the protection of your database, the less probability of an attacker succeeding in exposing or abusing any stored information. Good design of the database schema and the application deals with your greatest fears.
[http://www.php.net/manual/en/security.database.php]

lcpPhp'security'hiding-PHP

name::
* McsEngl.lcpPhp'security'hiding-PHP@cptIt,

Hiding PHP

In general, security by obscurity is one of the weakest forms of security. But in some cases, every little bit of extra security is desirable.

A few simple techniques can help to hide PHP, possibly slowing down an attacker who is attempting to discover weaknesses in your system. By setting expose_php to off in your php.ini file, you reduce the amount of information available to them.

Another tactic is to configure web servers such as apache to parse different filetypes through PHP, either with an .htaccess directive, or in the apache configuration file itself.
[http://www.php.net/manual/en/security.hiding.php]

lcpPhp'security'keeping-current

name::
* McsEngl.lcpPhp'security'keeping-current@cptIt,

Keeping Current

PHP, like any other large system, is under constant scrutiny and improvement. Each new version will often include both major and minor changes to enhance security and repair any flaws, configuration mishaps, and other issues that will affect the overall security and stability of your system.

Like other system-level scripting languages and programs, the best approach is to update often, and maintain awareness of the latest versions and their changes.
[http://www.php.net/manual/en/security.current.php]

lcpPhp'security'PHP-parser-outside-of-web-tree

name::
* McsEngl.lcpPhp'security'PHP-parser-outside-of-web-tree@cptIt,

Case 4: PHP parser outside of web tree

A very secure option is to put the PHP parser binary somewhere outside of the web tree of files. In /usr/local/bin, for example. The only real downside to this option is that you will now have to put a line similar to:

#!/usr/local/bin/php
as the first line of any file containing PHP tags. You will also need to make the file executable. That is, treat it exactly as you would treat any other CGI script written in Perl or sh or any other common scripting language which uses the#! shell-escape mechanism for launching itself.
To get PHP to handle PATH_INFO and PATH_TRANSLATED information correctly with this setup, the PHP parser should be compiled with the --enable-discard-path configure option.
[http://www.php.net/manual/en/security.cgi-bin.shell.php]

lcpPhp'security'sch.gr

name::
* McsEngl.lcpPhp'security'sch.gr@cptIt,

from  listserver@sch.gr
to  "phpusers@sch.gr" <phpusers@sch.gr>
date  Mon, Sep 26, 2011 at 6:10 PM
subject  [phpusers] Θέματα ασφαλείας δικτυακών τόπων
unsubscribe  Unsubscribe from this sender
hide details 6:10 PM (3 hours ago)
Φίλοι εκπαιδευτικοί,

Το μήνυμα αυτό αφορά στα προβλήματα ασφαλείας τα οποία προκύπτουν από την απρόσεκτη χρήση εφαρμογών (κυρίως διαχείρισης ιστοσελίδων), οι οποίες έχουν υλοποιηθεί με τη γλώσσα php. Παραδείγματα τέτοιων εφαρμογών είναι ενδεικτικά οι Mambo, PostNuke, PHPNuke, Joomla, WordPress και phpBB.

Οι εφαρμογές αυτές γίνονται συχνά στόχος επίθεσης από κακόβουλους χρήστες, με αποτέλεσμα την μή εξουσιοδοτημένη πρόσβαση και αλλοίωση του περιεχόμενου του ιστοχώρου που εξυπηρετούν. Τα προβλήματα ασφαλείας συνήθως οφείλονται σε κομμάτια κώδικα που κάνουν κακή χρήση της γλώσσας προγραμ-ματισμού PHP (π.χ. components ή plugins) και όχι σ’ αυτή καθ’ αυτή τη γλώσσα. Πρόσφατο κενό ασφαλείας εντοπίστηκε στο component oziogallery2 του Joomla.

Όταν ανακαλύπτονται κενά ασφαλείας σε κάποια δικτυακή εφαρμογή, αυτά συνήθως ανακοινώνονται στην επίσημη ιστοσελίδα της ομάδας που την αναπτύσσει αλλά ταυτόχρονα και σε ιστοσελίδες ειδικευμένων ομάδων ασφαλείας όπως για παράδειγμα οι http://nvd.nist.gov και http://www.frsirt.com.

Κατά κανόνα, όταν παραβιάζεται η ασφάλεια κάποιας εφαρμογής php οι επιτιθέμενοι εκμεταλλεύονται ευπάθειες του λογισμικού, οι οποίες είναι γνωστές και έχουν αντιμετωπισθεί από τους παρόχους του λογισμικού. Οι διαχειριστές όμως έχουν αμελήσει να ενημερώσουν το λογισμικό τους, με αποτέλεσμα να παραμένουν ευάλωτοι.

Προτεινόμενα βήματα για την πρόληψη παραβίασης της ασφάλειας των web εφαρμογών που χρησιμοποιούμε είναι:

* Όταν επιλέγουμε την web εφαρμογή που θα χρησιμοποιήσουμε, να λαμβάνουμε υπόψη την υποστήριξη που αυτή παρέχει σε θέματα ασφάλειας (έγκαιρη αντιμετώπιση προβλημάτων ασφάλειας, ευκολία εγκατάστασης των σχετικών διορθώσεων).

* Να παρακολουθούμε ηλεκτρονικές ομάδες συζητήσεων (forum) που ασχολούνται με την ασφάλεια τουλάχιστον για το λογισμικό που χρησιμοποιούμε, ώστε να ενημερωνόμαστε έγκαιρα όταν υπάρχουν νέες εκδόσεις που αντιμετωπίζουν ανακοινωμένες ευπάθειες.

* Πριν την εγκατάσταση πρόσθετων προγραμμάτων (components, plugins) να κάνουμε έλεγχο για τυχόν κενά ασφαλείας.

* Να φροντίζουμε για την ενημέρωση του λογισμικού μας και των επιμέρους προγραμμάτων που χρησιμοποιεί, όπως components/plugins αμέσως μόλις δημοσιοποιηθεί τρόπος αντιμετώπισης κάποιας ευπάθειας (ενημέρωση ασφαλείας).

* Να μην αποκαλύπτουμε δημόσια τις ακριβείς εκδόσεις των εφαρμογών που χρησιμοποιούμε, γιατί έτσι διευκολύνουμε την αναζήτηση των ευπαθών συστημάτων με χρήση μηχανών αναζήτησης από κακόβουλους χρήστες.

* Να ενεργοποιούμε μόνο τα χαρακτηριστικά που είναι απολύτως απαραίτητα στις εφαρμογές αυτές, π.χ. αν είναι δυνατό να αποφεύγουμε την ενεργοποίηση των ομάδων συζητήσεων (for a - phpBB) στα CMS, γιατί συχνά αποτελούν στόχο επίθεσης.


Χρήσιμοι σύνδεσμοι :
1. http://news.netcraft.com/archives/2006/01/31/php_apps_a_growing_target_for_hackers.htm

2. http://nvd.nist.gov/nvd.cfm

3. http://www.frsirt.com/english

Εκφράζουμε τα συγχαρητήρια μας για τους εξαιρετικούς δικτυακούς τόπους που αναπτύσσετε, από άποψη τεχνολογιών, και περιεχόμενου..

Σας ευχαριστούμε για τη συνεργασία σας και σας ευχόμαστε καλή σχολική χρονιά.

Με εκτίμηση

Πανελλήνιο Σχολικό Δίκτυο
-Υπηρεσία φιλοξενίας ιστοσελίδων:
E-mail: webhost@sch.gr
-Ομάδα αντιμετώπισης περιστατικών ασφαλείας (GSN-CERT)
http://cert.sch.gr, E-mail: cert@sch.gr

lcpPhp'security'Suhosin

name::
* McsEngl.lcpPhp'security'Suhosin@cptIt,
* McsEngl.suhosin@cptIt585i,

_DESCRIPTION:
Suhosin is an advanced protection system for PHP installations. It was designed to protect servers and users from known and unknown flaws in PHP applications and the PHP core. Suhosin comes in two independent parts, that can be used separately or in combination. The first part is a small patch against the PHP core, that implements a few low-level protections against bufferoverflows or format string vulnerabilities and the second part is a powerful PHP extension that implements all the other protections.
[http://www.hardened-php.net/suhosin/]

lcpPhp'security'variable-checking

name::
* McsEngl.lcpPhp'security'variable-checking@cptIt,

You should always carefully examine your code to make sure that any variables being submitted from a web browser are being properly checked, and ask yourself the following questions:

Will this script only affect the intended files?
Can unusual or undesirable data be acted upon?
Can this script be used in unintended ways?
Can this be used in conjunction with other scripts in a negative manner?
Will any transactions be adequately logged?
[http://www.php.net/manual/en/security.variables.php]

lcpPhp'tool.REPL

name::
* McsEngl.lcpPhp'tool.REPL@cptIt,
* McsEngl.lcpPhp'repl@cptIt,

_ADDRESS.WPG:
* http://phpepl.cloudcontrolled.com//

ruby'method.CUSTOM

name::
* McsEngl.ruby'method.CUSTOM@cptIt,

_CODE.RUBY:
def sayMoo
puts 'mooooooo...'
end
...
def sayMoo numberOfMoos
puts 'mooooooo...'*numberOfMoos
end
[http://pine.fm/LearnToProgram/?Chapter=08]

ruby'program'executing

name::
* McsEngl.ruby'program'executing@cptIt,

_DESCRIPTION:
Running Ruby

Now that Ruby is installed, you'd probably like to run some programs. Unlike compiled environments, there are two ways to run Ruby---interactively and as a program.
Interactive Ruby

The easiest way to run Ruby interactively is simply to type ``ruby'' at the shell prompt.
% ruby
puts "Hello, world!"
^D
Hello, world!
Here we typed in the single puts expression and an end of file character (which is control-D on our system). This process works, but it's sort of painful if you make a typo, and you can't really see what's going on as you type.
In the sample directory in the Ruby distribution you'll find a script named ``eval.rb''. It goes one step better by showing us the value of each expression as it is entered:
% cd sample
% ruby eval.rb
ruby> a = "Hello, world!"
"Hello, world!"
ruby> puts a
Hello, world!
nil
ruby> ^D
%
Here we can see the output from puts, and then the return value from puts (which is nil).
That's all fine and well, except that multiline expressions do not work, and you can't edit the line you're on, or go back and use previous lines (as you might with command history in a shell).
For the next step up from eval.rb, we have irb---Interactive Ruby. irb is a Ruby Shell, complete with command-line history, line editing capabilities, and job control. It is quite configurable and has many options, so much so that it has its own appendix beginning on page 517. We recommend that you get familiar with irb so you can try some of our examples interactively.
Ruby Programs

Finally, you can run a Ruby program from a file as you would any other shell script, Perl program, or Python program. You can simply run Ruby giving the script name as an argument:
% ruby myprog.rb
Or you can use the Unix ``shebang'' notation as the first line of the program file.[If your system supports it, you can avoid hard-coding the path to Ruby in the shebang line by using#!/usr/bin/env ruby, which will search your path for ruby and then execute it.]
#!/usr/local/bin/ruby -w

puts "Hello, World!"
If you make this source file executable (using, for instance, chmod +x myprog.rb), Unix lets you run the file as a program:
% ./myprog.rb
Hello, World!
You can do something similar under Microsoft Windows using file associations.
[http://ruby-doc.com/docs/ProgrammingRuby/]

ruby'program.EXAMPLE

name::
* McsEngl.ruby'program.EXAMPLE@cptIt,

_CODE.RUBY:
Now that you've gotten everything setup, let's write a program! Open up your favorite text editor and type in the following:
puts 1+2
Save your program (yes, that's a program!) as calc.rb (the .rb is what we usually put at the end of programs written in Ruby). Now run your program by typing ruby calc.rb into your command line. It should have put a 3 on your screen.
[http://pine.fm/LearnToProgram/?Chapter=01]

lua'Advantage

name::
* McsEngl.lua'Advantage@cptIt,

Lua is a powerful language that can express solutions to problems in a variety of domains. Yet Python, Ruby and Perl are also quite powerful in their way. Lua's primary advantage over other languages is its compact, efficient size. This size, and the ease of integrating and extending Lua into a particular programming problem is the reason Lua is worthy of examination.
[http://onlamp.com/lpt/a/6467]

lua'Case-sensitivity

name::
* McsEngl.lua'Case-sensitivity@cptIt,

Lua is a case-sensitive language: and is a reserved word, but And and AND are two different, valid names. As a convention, names starting with an underscore followed by uppercase letters (such as _VERSION) are reserved for variables used by Lua.
[http://www.lua.org/manual/5.2/manual.html#h5o-13]

lua'Embdddability

name::
* McsEngl.lua'Embdddability@cptIt,

Lua is embeddable

Lua is a fast language engine with small footprint that you can embed easily into your application. Lua has a simple and well documented API that allows strong integration with code written in other languages. It is easy to extend Lua with libraries written in other languages. It is also easy to extend programs written in other languages with Lua. Lua has been used to extend programs written not only in C and C++, but also in Java, C#, Smalltalk, Fortran, Ada, Erlang, and even in other scripting languages, such as Perl and Ruby.
[http://www.lua.org/about.html]

lua'Inheritance

name::
* McsEngl.lua'Inheritance@cptIt,

Lua, for instance, does not contain explicit support for inheritance, but allows it to be implemented relatively easily with metatables.
[http://en.wikipedia.org/wiki/Lua_(programming_language)]

lua'Keyword

name::
* McsEngl.lua'Keyword@cptIt,

The following keywords are reserved and cannot be used as names:
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
[http://www.lua.org/manual/5.2/manual.html#h5o-13]

lua'Licence

name::
* McsEngl.lua'Licence@cptIt,

1.6 – Is Lua compatible with GPL software?

Yes. Up until Lua 4.0, the license was perhaps a bit unclear about this. Since Lua 5.0, Lua is distributed under the terms of the very liberal and well-known MIT license, which is compatible with GPL and is approved by the Open Source Initiative. Read the details in the license page.
[http://www.lua.org/faq.html]

lua'data.Number

name::
* McsEngl.lua'data.Number@cptIt,
* McsEngl.lua'number@cptIt,

_GENERIC:
* lua-codeType#ql:lua'type#

Number represents real (double-precision floating-point) numbers. Operations on numbers follow the same rules of the underlying C implementation, which, in turn, usually follows the IEEE 754 standard. (It is easy to build Lua interpreters that use other internal representations for numbers, such as single-precision floats or long integers; see file luaconf.h.)
[http://www.lua.org/manual/5.2/manual.html#h5o-4]

lua'data.Programer

name::
* McsEngl.lua'data.Programer@cptIt,

Lua is a dynamically typed language intended for use as an extension or scripting language, and is compact enough to fit on a variety of host platforms. It supports only a small number of atomic data structures such as boolean values, numbers (double-precision floating point by default), and strings. Typical data structures such as arrays, sets, lists, and records can be represented using Lua’s single native data structure, the table, which is essentially a heterogeneous associative array.
[http://en.wikipedia.org/wiki/Lua_(programming_language)]

lua'data.String

name::
* McsEngl.lua'data.String@cptIt,
* McsEngl.lua'string@cptIt,

_GENERIC:
* lua-codeType#ql:lua'type#

_DESCRIPTION:
String represents immutable sequences of bytes. Lua is 8-bit clean: strings can contain any 8-bit value, including embedded zeros ('\0').
[http://www.lua.org/manual/5.2/manual.html#h5o-4]
===
-- Example 8 -- Strings.
a="single 'quoted' string and double \"quoted\" string inside"
b='single \'quoted\' string and double "quoted" string inside'
c= [[ multiple line
with 'single'
and "double" quoted strings inside.]]

print(a)
print(b)
print(c)


-------- Output ------

single 'quoted' string and double "quoted" string inside
single 'quoted' string and double "quoted" string inside
multiple line
with 'single'
and "double" quoted strings inside.
[lfw intro]

lua'string'resource:
* http://lua-users.org/wiki/LuaUnicode,

SPECIFIC

lua'fn.example

name::
* McsEngl.lua'fn.example@cptIt,

function sayhello(person)
print("Hello "..person)
end

lua'fn.library

name::
* McsEngl.lua'fn.library@cptIt,
* McsEngl.lua'library@cptIt,

lua'fn.library.Auxiliary

name::
* McsEngl.lua'fn.library.Auxiliary@cptIt,

_SPECIFIC:
auxiliary library

luaL_Buffer
luaL_Reg
luaL_addchar
luaL_addlstring
luaL_addsize
luaL_addstring
luaL_addvalue
luaL_argcheck
luaL_argerror
luaL_buffinit
luaL_buffinitsize
luaL_callmeta
luaL_checkany
luaL_checkinteger
luaL_checkint
luaL_checklong
luaL_checklstring
luaL_checknumber
luaL_checkoption
luaL_checkstack
luaL_checkstring
luaL_checktype
luaL_checkudata
luaL_checkunsigned
luaL_checkversion
luaL_dofile
luaL_dostring
luaL_error
luaL_execresult
luaL_fileresult
luaL_getmetafield
luaL_getmetatable
luaL_getsubtable
luaL_gsub
luaL_len
luaL_loadbuffer
luaL_loadbufferx
luaL_loadfile
luaL_loadfilex
luaL_loadstring
luaL_newlib
luaL_newlibtable
luaL_newmetatable
luaL_newstate
luaL_openlibs
luaL_optinteger
luaL_optint
luaL_optlong
luaL_optlstring
luaL_optnumber
luaL_optstring
luaL_optunsigned
luaL_prepbuffer
luaL_prepbuffsize
luaL_pushresult
luaL_pushresultsize
luaL_ref
luaL_requiref
luaL_setfuncs
luaL_setmetatable
luaL_testudata
luaL_tolstring
luaL_traceback
luaL_typename
luaL_unref
luaL_where

lua'fn.library.Basic

name::
* McsEngl.lua'fn.library.Basic@cptIt,
* McsEngl.lua'basic-library@cptIt,

The basic library provides core functions to Lua. If you do not include this library in your application, you should check carefully whether you need to provide implementations for some of its facilities.
[http://www.lua.org/manual/5.2/manual.html#h5o-234]

_SPECIFIC:
_G
_VERSION
assert
collectgarbage
dofile
error
getmetatable
ipairs
loadfile
load
next
pairs
pcall
print
rawequal
rawget
rawlen
rawset
require
select
setmetatable
tonumber
tostring
type
xpcall

lua'fn.library.Bitwise

name::
* McsEngl.lua'fn.library.Bitwise@cptIt,
* McsEngl.lua'bitwise-library@cptIt,

_SPECIFIC:
bit32.arshift
bit32.band
bit32.bnot
bit32.bor
bit32.btest
bit32.bxor
bit32.extract
bit32.lrotate
bit32.lshift
bit32.replace
bit32.rrotate
bit32.rshift

lua'fn.library.IO

name::
* McsEngl.lua'fn.library.IO@cptIt,
* McsEngl.lua'io-library@cptIt,

_SPECIFIC:
file:close
file:flush
file:lines
file:read
file:seek
file:setvbuf
file:write
io.close
io.flush
io.input
io.lines
io.open
io.output
io.popen
io.read
io.stderr
io.stdin
io.stdout
io.tmpfile
io.type
io.write

lua'fn.library.Math

name::
* McsEngl.lua'fn.library.Math@cptIt,
* McsEngl.lua'math-library@cptIt,

This library is an interface to the standard C math library. It provides all its functions inside the table math.
[http://www.lua.org/manual/5.2/manual.html#h5o-303]

_SPECIFIC:
math.abs
math.acos
math.asin
math.atan
math.atan2
math.ceil
math.cos
math.cosh
math.deg
math.exp
math.floor
math.fmod
math.frexp
math.huge
math.ldexp
math.log
math.max
math.min
math.modf
math.pi
math.pow
math.rad
math.random
math.randomseed
math.sin
math.sinh
math.sqrt
math.tan
math.tanh

lua'fn.library.Operating-system

name::
* McsEngl.lua'fn.library.Operating-system@cptIt,
* McsEngl.lua'os-library@cptIt,

_SPECIFIC:
os.clock
os.date
os.difftime
os.execute
os.exit
os.getenv
os.remove
os.rename
os.setlocale
os.time
os.tmpname

lua'fn.library.Standard

name::
* McsEngl.lua'fn.library.Standard@cptIt,
* McsEngl.lua'standard-library@cptIt,

All libraries are implemented through the official C API and are provided as separate C modules. Currently, Lua has the following standard libraries:

basic library (§6.1);
coroutine library (§6.2);
package library (§6.3);
string manipulation (§6.4);
table manipulation (§6.5);
mathematical functions (§6.6) (sin, log, etc.);
bitwise operations (§6.7);
input and output (§6.8);
operating system facilities (§6.9);
debug facilities (§6.10).
[http://www.lua.org/manual/5.2/manual.html#h5o-233]

lua'fn.print

name::
* McsEngl.lua'fn.print@cptIt,
* McsEngl.lua'print-function@cptIt,

lua'fn.type

name::
* McsEngl.lua'fn.type@cptIt,
* McsEngl.lua'type-function@cptIt,

The library function type returns a string describing the type of a given value (see §6.1).
[http://www.lua.org/manual/5.2/manual.html#h5o-4]

lua'ns'Creating

name::
* McsEngl.lua'ns'Creating@cptIt,

Modules can be easily created by creating a file a.lua with the following content:

module(..., package.seeall);

function foo() print("Hello World!") end
The special table package will be explained later.

Now to use this new module just do:

> require "a"
> a.foo()
Hello World!
[http://lua-users.org/wiki/ModulesTutorial]

lua'Block

name::
* McsEngl.lua'Block@cptIt,

lua'Expression

name::
* McsEngl.lua'Expression@cptIt,

lua'Name

name::
* McsEngl.lua'Name@cptIt,
* McsEngl.lua'identifier@cptIt,

Names (also called identifiers) in Lua can be any string of letters, digits, and underscores, not beginning with a digit. Identifiers are used to name variables, table fields, and labels.

The following keywords are reserved and cannot be used as names:
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
Lua is a case-sensitive language: and is a reserved word, but And and AND are two different, valid names. As a convention, names starting with an underscore followed by uppercase letters (such as _VERSION) are reserved for variables used by Lua.
[http://www.lua.org/manual/5.2/manual.html#h5o-13]

lua'Statement

name::
* McsEngl.lua'Statement@cptIt,

Lua supports an almost conventional set of statements, similar to those in Pascal or C. This set includes assignments, control structures, function calls, and variable declarations.
[http://www.lua.org/manual/5.2/manual.html#h5o-15]

lua'Token

name::
* McsEngl.lua'Token@cptIt,

The following strings denote other tokens:
+ - * / % ^#
== ~= <= >= < > =
( ) { } [ ] ::
; : , . .. ...
[http://www.lua.org/manual/5.2/manual.html#h5o-13]

lua'program.Host

name::
* McsEngl.lua'program.Host@cptIt,
* McsEngl.lua'host@cptIt,

Being an extension language, Lua has no notion of a "main" program: it only works embedded in a host client, called the embedding program or simply the host. The host program can invoke functions to execute a piece of Lua code, can write and read Lua variables, and can register C functions to be called by Lua code. Through the use of C functions, Lua can be augmented to cope with a wide range of different domains, thus creating customized programming languages sharing a syntactical framework. The Lua distribution includes a sample host program called lua, which uses the Lua library to offer a complete, standalone Lua interpreter, for interactive or batch use.
[http://www.lua.org/manual/5.2/manual.html#h5o-2]

lua'table'Function

name::
* McsEngl.lua'table'Function@cptIt,

A = {}

function A:add(x,y)
return x+y
end

print( A:add(1,5) )
[http://lua-users.org/wiki/ClassesAndMethods]

lua'table'Key

name::
* McsEngl.lua'table'Key@cptIt,
* McsEngl.lua'table'field@cptIt,

Any key with value nil is not considered part of the table.
...
Lua uses the field name as an index. The language supports this representation by providing a.name as syntactic sugar for a["name"]. There are several convenient ways to create tables in Lua (see §3.4.8).
[http://www.lua.org/manual/5.2/manual.html#h5o-4]

The following two forms of accessing the table are equivalent when the table keys are strings:
t3["Name"] = "Keith"
t3.Name = "Keith"
[http://onlamp.com/lpt/a/6467]

> y = { const={ name="Pi", value=3.1415927 }, const2={ name="light speed", value=3e8 } }
> print(y.const.name)
Pi
[http://lua-users.org/wiki/LuaTypesTutorial]

lua'table'Value

name::
* McsEngl.lua'table'Value@cptIt,

SPECIFIC

lua'table.Example

name::
* McsEngl.lua'table.Example@cptIt,

Here are some examples of table usage in Lua:

a = {} -- Initializes an empty table
a[1] = "Fred" -- Assigns "Fred" to the entry indexed by the number 1
a["1"] = 7 -- Assigns the number 7 to the entry indexed by the string "1"
[http://onlamp.com/lpt/a/6467]

> t = { 11, 22, 33, you='one', me='two' }
> table.foreach(t,print)
1 11
2 22
3 33
me two
you one
>
> = t[2]
22
> = t.me
two
> = t.fred
nil
[http://lua-users.org/wiki/LuaClassesWithMetatable]

lua'table.Metatable

name::
* McsEngl.lua'table.Metatable@cptIt,

Every value in Lua can have a metatable. This metatable is an ordinary Lua table that defines the behavior of the original value under certain special operations. You can change several aspects of the behavior of operations over a value by setting specific fields in its metatable. For instance, when a non-numeric value is the operand of an addition, Lua checks for a function in the field "__add" of the value's metatable. If it finds one, Lua calls this function to perform the addition.
[http://www.lua.org/manual/5.2/manual.html#h5o-7]

lua'table.Sequence

name::
* McsEngl.lua'table.Sequence@cptIt,

We use the term sequence to denote a table where the set of all positive numeric keys is equal to {1..n} for some integer n, which is called the length of the sequence (see §3.4.6).
[http://www.lua.org/manual/5.2/manual.html#h5o-4]

lua'Interpreter

name::
* McsEngl.lua'Interpreter@cptIt,

Despite the small size of the Lua interpreter, the language itself is quite rich.
[http://onlamp.com/lpt/a/6467]

lua'interpreter.JS

name::
* McsEngl.lua'interpreter.JS@cptIt,

_ADDRESS.WPG:
* http://syntensity.com/static/lua.html,

lua'type'Quering

name::
* McsEngl.lua'type'Quering@cptIt,

Querying type

As Lua is a reflective language, we can use the Lua function type() to get a description of the type of a particular object.

> x = "123" -- a string
> print(x, type(x)) -- show the value of x and its type
123 string
> x = x + 7 -- add a number to the string which forces coercion
> print(x, type(x)) -- again show the value and type
130 number
[http://lua-users.org/wiki/LuaTypesTutorial]

SPECIFIC

lua'boolean-type

name::
* McsEngl.lua'boolean-type@cptIt,

Boolean is the type of the values false and true. Both nil and false make a condition false; any other value makes it true.
[http://www.lua.org/manual/5.2/manual.html]
any expression that does not evaluate to nil is true.
[http://onlamp.com/lpt/a/6467]

nil and false are the only Non-Truth Values
In JavaScript, "" and 0 equate as false when used in conditionals. In Lua, only nil and false evaluate as false.
[http://phrogz.net/lua/LearningLua_FromJS.html]

lua'nil-type

name::
* McsEngl.lua'nil-type@cptIt,

Nil is the type of the value nil, whose main property is to be different from any other value; it usually represents the absence of a useful value.
[http://www.lua.org/manual/5.2/manual.html]

lua'object

name::
* McsEngl.lua'object@cptIt,

_DESCRIPTION:
Tables, functions, threads, and (full) userdata values are objects: variables do not actually contain these values, only references to them. Assignment, parameter passing, and function returns always manipulate references to such values; these operations do not imply any kind of copy.
[http://www.lua.org/manual/5.2/manual.html]

_SPECIFIC:
* full-userdata#ql:lua'userdata_type#,
* function#ql:lua'function#,
* table#ql:lua'table#,
* thread,

lua'thread-type

name::
* McsEngl.lua'thread-type@cptIt,

_GENERIC:
* lua-object#ql:lua'object#

The type thread represents independent threads of execution and it is used to implement coroutines (see §2.6). Do not confuse Lua threads with operating-system threads. Lua supports coroutines on all systems, even those that do not support threads.
[http://www.lua.org/manual/5.2/manual.html]

lua'userdata-type

name::
* McsEngl.lua'userdata-type@cptIt,

_GENERIC:
* lua-object#ql:lua'object#

The type userdata is provided to allow arbitrary C data to be stored in Lua variables. A userdata value is a pointer to a block of raw memory. There are two kinds of userdata: full userdata, where the block of memory is managed by Lua, and light userdata, where the block of memory is managed by the host. Userdata has no predefined operations in Lua, except assignment and identity test. By using metatables, the programmer can define operations for full userdata values (see §2.4). Userdata values cannot be created or modified in Lua, only through the C API. This guarantees the integrity of data owned by the host program.
[http://www.lua.org/manual/5.2/manual.html]

lua'Value

name::
* McsEngl.lua'Value@cptIt,

Lua is a dynamically typed language. This means that variables do not have types; only values do. There are no type definitions in the language. All values carry their own type.
All values in Lua are first-class values. This means that all values can be stored in variables, passed as arguments to other functions, and returned as results.
[http://www.lua.org/manual/5.2/manual.html]

lua'value'metatable,

_SPECIFIC:
* NaN,
* nil,

lua'variable'name

name::
* McsEngl.lua'variable'name@cptIt,

-- Variable names consist of letters, digits and underscores.
-- They cannot start with a digit.

one_two_3 = 123 -- is valid varable name

-- 1_two_3 is not a valid variable name.
[lfw intro]

lua'variable.local

name::
* McsEngl.lua'variable.local@cptIt,
* McsEngl.lua'local-keyword@cptIt,

Global Variables by Default

In JS, if you are inside a function and assign a value to a previously-unseen variable, the variable will be local if the var keyword was used, and global otherwise:

function foo( )
{
var jim = "This variable is local to the foo function";
jam = "This variable is in global scope";
}
Similarly in Lua, the local keyword indicates a local variable, while omitting it indicates a global variable:

function foo( )
local jim = "This variable is local to the foo function";
jam = "This variable is in global scope";
end
[http://phrogz.net/lua/LearningLua_FromJS.html]

lfw'PART

name::
* McsEngl.lfw'PART@cptIt,

Installer Lua Interpreter, Lua Reference Manual, Quick Lua Tour Sample, Examples directory, Libraries with documentation. Lua Compiler (luac) Text Editors (SciTE and I think maybe wxLua editors too) C header files/libraries/etc. for building C module
[http://code.google.com/p/luaforwindows/]

lfw'Evolution

name::
* McsEngl.lfw'Evolution@cptIt,

_2011-06-08:
5.1.4-44 08/June/2011 - 30th release
Fixed pl.dir so you can use strict module

_2008-07-09:
5.1.3.12 9/July/2008 - First release

lfw'Installation

name::
* McsEngl.lfw'Installation@cptIt,

Lua for Windows installs Lua language, SciTE based Lua IDE and Lua modules to the directory of you choice at install time. Lua for Windows and it's modules all depend on the MSVC++ 2005 runtime library. Lua for Windows install will automatically download this runtime and install it for you if you don't have runtime installed on your computer. The runtime is contained in the file vcredist_x86.exe, if you don't want this download to occur at installation then place the vcredist_86.exe in same directory as Lua for Windows install exe.
[http://code.google.com/p/luaforwindows/]

lpy'Compilation

name::
* McsEngl.lpy'Compilation@cptIt,

It can be used as a scripting language or can be compiled to byte-code for building large applications.
[http://wiki.python.org/moin/BeginnersGuide/Overview]

lpy'Memory-management

name::
* McsEngl.lpy'Memory-management@cptIt,

Python's automatic memory management frees you from having to manually allocate and free memory in your code.
[http://wiki.python.org/moin/BeginnersGuide/Overview]

lpy'Programming-method

name::
* McsEngl.lpy'Programming-method@cptIt,

Support for functional and structured programming methods as well as OOP.
[http://www.tutorialspoint.com/python/python_overview.htm]

lpy'Scalability

name::
* McsEngl.lpy'Scalability@cptIt,

Scalable: Python provides a better structure and support for large programs than shell scripting.
[http://www.tutorialspoint.com/python/python_overview.htm]

lpy'archetype'DomainIn

name::
* McsEngl.lpy'archetype'DomainIn@cptIt,
* McsEngl.lpy'DomainIn@cptIt,
* McsEngl.lpy'usage@cptIt,

lpy'Object

name::
* McsEngl.lpy'Object@cptIt,

_DESCRIPTION:
2.4.2. What's an Object?
Everything in Python is an object, and almost everything has attributes and methods. All functions have a built-in attribute __doc__, which returns the doc string defined in the function's source code. The sys module is an object which has (among other things) an attribute called path. And so forth.
Still, this begs the question. What is an object?
Different programming languages define “object” in different ways.
In some, it means that all objects must have attributes and methods; in others, it means that all objects are subclassable.
In Python, the definition is looser; some objects have neither attributes nor methods (more on this in Chapter 3), and not all objects are subclassable (more on this in Chapter 5).
But everything is an object in the sense that it can be assigned to a variable or passed as an argument to a function (more in this in Chapter 4).
This is so important that I'm going to repeat it in case you missed it the first few times: everything in Python is an object. Strings are objects. Lists are objects. Functions are objects. Even modules are objects.
[http://www.diveintopython.net/getting_to_know_python/everything_is_an_object.html]
[http://diveintopython.org/getting_to_know_python/everything_is_an_object.html]
===
Without getting technical, an object is the basic Python building block, the ‘lego brick’ with which every program is built. All the elements that we’ve met up until now - integers, strings, lists, functions etc. - they’re all objects. And a class is simply a user-defined object that lets you keep a bunch of closely related things “together”. COMMENT:Not sure about this paragraph - Gerard
[http://effbot.org/pytut/node11-baseline.htm]

pyalgo'code

name::
* McsEngl.pyalgo'code@cptIt,
* McsEngl.lpy'Processing-code@cptIt,
* McsEngl.lpy'operation@cptIt,

_ATTRIBUTE:
* py-operator#ql:py'operator#

pyalgo.Arithmetic

name::
* McsEngl.pyalgo.Arithmetic@cptIt,

pyalgo.Boolean

name::
* McsEngl.pyalgo.Boolean@cptIt,

pyalgo.Comparison

name::
* McsEngl.pyalgo.Comparison@cptIt,

pyalgo.Shifting

name::
* McsEngl.pyalgo.Shifting@cptIt,

pyclass'code

name::
* McsEngl.pyclass'code@cptIt,
* McsEngl.lpy'code.CLASS@cptIt,

_SPECIFIC:
* class-statement

pyclass'documentation

name::
* McsEngl.pyclass'documentation@cptIt,

_DESCRIPTION:
The class statement creates a new class definition. The name of the class immediately follows the keyword class followed by a colon as follows:
class ClassName:
'Optional class documentation string'
class_suite

The class has a documentation string which can be access via ClassName.__doc__.
[http://www.tutorialspoint.com/python/python_classes_objects.htm]

pyclass'doing.CREATING

name::
* McsEngl.pyclass'doing.CREATING@cptIt,

_DESCRIPTION:
The class statement creates a new class definition. The name of the class immediately follows the keyword class followed by a colon as follows:

class ClassName:
'Optional class documentation string'
class_suite

The class has a documentation string which can be access via ClassName.__doc__.

The class_suite consists of all the component statements, defining class members, data attributes, and functions.

Example:

Following is the example of a simple Python class:

class Employee:
'Common base class for all employees'
empCount = 0

def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1

def displayCount(self):
print "Total Employee %d" % Employee.empCount

def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
[http://www.tutorialspoint.com/python/python_classes_objects.htm]

pyclass'function

name::
* McsEngl.pyclass'function@cptIt,
* McsEngl.lpyclass'method@cptIt,

pyclass'variable

name::
* McsEngl.pyclass'variable@cptIt,

SPECIFIC

pyclass.INSTANCE

name::
* McsEngl.pyclass.INSTANCE@cptIt,

_DESCRIPTION:
Creating instance objects:
To create instances of a class, you call the class using class name and pass in whatever arguments its __init__ method accepts.

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
[http://www.tutorialspoint.com/python/python_classes_objects.htm]

pyclass.example

name::
* McsEngl.pyclass.example@cptIt,

class Dog:

kind = 'canine' # class variable shared by all instances

def __init__(self, name):
self.name = name # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind # shared by all dogs
'canine'
>>> e.kind # shared by all dogs
'canine'
>>> d.name # unique to d
'Fido'
>>> e.name # unique to e
'Buddy'
[https://docs.python.org/3/tutorial/classes.html#class-and-instance-variables]

lpy'ex.class:
class BankAccount(object):
def __init__(self, initial_balance=0):
self.balance = initial_balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
def overdrawn(self):
return self.balance < 0
my_account = BankAccount(15)
my_account.withdraw(5)
print my_account.balance

pyf'doing.Calling

name::
* McsEngl.pyf'doing.Calling@cptIt,

Calling a Function
Defining a function only gives it a name, specifies the parameters that are to be included in the function, and structures the blocks of code.

Once the basic structure of a function is finalized, you can execute it by calling it from another function or directly from the Python prompt.

Following is the example to call printme() function:

#!/usr/bin/python

# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;

# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
This would produce following result:

I'm first call to user defined function!
Again second call to the same function
[http://www.tutorialspoint.com/python/python_functions.htm]

pyf'Pass-by-reference

name::
* McsEngl.pyf'Pass-by-reference@cptIt,

All parameters (arguments) in the Python language are passed by reference. It means if you change what a parameter refers to within a function, the change also reflects back in the calling function. For example:

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist.append([1,2,3,4]);
print "Values inside the function: ", mylist
return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
Here we are maintaining reference of the passed object and appending values in the same object. So this would produce following result:

Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

There is one more example where argument is being passed by reference but inside the function, but the reference is being over-written.

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4];# This would assig new reference in mylist
print "Values inside the function: ", mylist
return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
The parameter mylist is local to the function changeme. Changing mylist within the function does not affect mylist. The function accomplishes nothing and finally this would produce following result:

Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
[http://www.tutorialspoint.com/python/python_functions.htm]

SPECIFIC

pyf.Anonymous

name::
* McsEngl.pyf.Anonymous@cptIt,

The Anonymous Functions:
You can use the lambda keyword to create small anonymous functions. These functions are called anonymous because they are not declared in the standard manner by using the def keyword.

Lambda forms can take any number of arguments but return just one value in the form of an expression. They cannot contain commands or multiple expressions.

An anonymous function cannot be a direct call to print because lambda requires an expression.

Lambda functions have their own local namespace and cannot access variables other than those in their parameter list and those in the global namespace.

Although it appears that lambda's are a one-line version of a function, they are not equivalent to inline statements in C or C++, whose purpose is by passing function stack allocation during invocation for performance reasons.

Syntax:

The syntax of lambda functions contains only a single statement, which is as follows:

lambda [arg1 [,arg2,.....argn]]:expression
Example:

Following is the example to show how lembda form of function works:

#!/usr/bin/python

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;



# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
This would produce following result:

Value of total : 30
Value of total : 40
[http://www.tutorialspoint.com/python/python_functions.htm]

pyf.BUILTIN

name::
* McsEngl.pyf.BUILTIN@cptIt,

_DESCRIPTION:
The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order.
Built-in Functions
__import__()
abs()
all()
any()
ascii()
bin()
bool()
bytearray()
bytes()
callable()
chr()
classmethod()
compile()
complex()
delattr()
dict()
dir()
divmod()
enumerate()
eval()
exec()
filter()
float()
format()
frozenset()
getattr()
globals()
hasattr()
hash()
help()
hex()
id()
input()
int()
isinstance()
issubclass()
iter()
len()
list()
locals()
map()
max()
memoryview()
min()
next()
object()
oct()
open()
ord()
pow()
print()
property()
range()
repr()
reversed()
round()
set()
setattr()
slice()
sorted()
staticmethod()
str()
sum()
super()
tuple()
type()
vars()
zip()
[http://docs.python.org/3/library/functions.html]

pyf.BUILTIN.NO

name::
* McsEngl.pyf.BUILTIN.NO@cptIt,
* McsEngl.lpyfunction.User-defined@cptIt,

pyfunction.GENERATOR

name::
* McsEngl.pyfunction.GENERATOR@cptIt,

_DESCRIPTION:
generator
A function which returns an iterator. It looks like a normal function except that it contains yield statements for producing a series a values usable in a for-loop or that can be retrieved one at a time with the next() function. Each yield temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the generator resumes, it picks-up where it left-off (in contrast to functions which start fresh on every invocation).
generator expression
An expression that returns an iterator. It looks like a normal expression followed by a for expression defining a loop variable, range, and an optional if expression. The combined expression generates values for an enclosing function:
>>>
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
285
[http://docs.python.org/3/glossary.html#term-generator]

pyf.len()

name::
* McsEngl.pyf.len()@cptIt,

>>> p = [1, q, 4]
>>> len(p)
3
[doc32]

pyf.print()

name::
* McsEngl.pyf.print()@cptIt,

print('The value of i is', i)
=> The value of i is 65536

lpy'number.Literal

name::
* McsEngl.lpy'number.Literal@cptIt,
* McsEngl.lpy'literal.number@cptIt,

_DESCRIPTION:
Python supports four different numerical types:

int (signed integers)
long (long integers [can also be represented in octal and hexadecimal])
float (floating point real values)
complex (complex numbers)

Examples:

Here are some examples of numbers:

int  long  float  complex
10  51924361L  0.0  3.14j
100  -0x19323L  15.20  45.j
-786  0122L  -21.9  9.322e-36j
080  0xDEFABCECBDAECBFBAEl  32.3+e18  .876j
-0490  535633629843L  -90.  -.6545+0J
-0x260  -052318172735L  -32.54e100  3e+26J
0x69  -4721885298529L  70.2-E12  4.53e-7j
[http://www.tutorialspoint.com/python/python_variable_types.htm]

pystring'function

name::
* McsEngl.pystring'function@cptIt,

str = 'Hello World!'

print str# Prints complete string
print str[0]# Prints first character of the string
print str[2:5]# Prints characters starting from 3rd to 6th
print str[2:]# Prints string starting from 3rd character
print str * 2# Prints string two times
print str + "TEST"# Prints concatenated string
This will produce following result:

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
[http://www.tutorialspoint.com/python/python_variable_types.htm]

pystring.literal

name::
* McsEngl.pystring.literal@cptIt,
* McsEngl.lpy'literal.string@cptIt,

Python accepts single ('), double (") and triple (''' or """) quotes to denote string literals, as long as the same type of quote starts and ends the string.

The triple quotes can be used to span the string across multiple lines. For example, all the following are legal:

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""
[http://www.tutorialspoint.com/python/python_basic_syntax.htm]

lpy'proc.Converting-datatype

name::
* McsEngl.lpy'proc.Converting-datatype@cptIt,

Data Type Conversion:
Sometimes you may beed to perform conversions between the built-in types. To convert between types you simply use the type name as a function.

There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value.

Function  Description
int(x [,base])

Converts x to an integer. base specifies the base if x is a string.

long(x [,base] )

Converts x to a long integer. base specifies the base if x is a string.

float(x)

Converts x to a floating-point number.

complex(real [,imag])

Creates a complex number.

str(x)

Converts object x to a string representation.

repr(x)

Converts object x to an expression string.

eval(str)

Evaluates a string and returns an object.

tuple(s)

Converts s to a tuple.

list(s)

Converts s to a list.

set(s)

Converts s to a set.

dict(d)

Creates a dictionary. d must be a sequence of (key,value) tuples.

frozenset(s)

Converts s to a frozen set.

chr(x)

Converts an integer to a character.

unichr(x)

Converts an integer to a Unicode character.

ord(x)

Converts a single character to its integer value.

hex(x)

Converts an integer to a hexadecimal string.

oct(x)

Converts an integer to an octal string.
[http://www.tutorialspoint.com/python/python_variable_types.htm]