Update README to contain information about initialization and basic usage

Author: lisachenko

README.md

@@ -2,7 +2,7 @@ Z-Engine library
 -----------------
 
 Have you ever dreamed about mocking a final class or redefining final method? Or maybe have an ability to work with existing classes in runtime?
-`Z-Engline` is a PHP library to access low-level structures of PHP itself. Forget about all existing limitations and use this library to transform your existing code in runtime by declaring new methods, adding new interface to the classes and even installing your own system hooks, like opcode compilation, object initalization and much more.
+`Z-Engline` is a PHP7.4 library that provides an API to PHP. Forget about all existing limitations and use this library to transform your existing code in runtime by declaring new methods, adding new interfaces to the classes and even installing your own system hooks, like opcode compilation, object initalization and much more.
 
 [![Build Status](https://secure.travis-ci.org/lisachenko/z-engine.png?branch=master)](https://travis-ci.org/lisachenko/z-engine)
 [![GitHub release](https://img.shields.io/github/release/lisachenko/z-engine.svg)](https://github.com/lisachenko/z-engine/releases/latest)
@@ -16,7 +16,49 @@ How it works?
 
 As you know, PHP version 7.4 contains a new feature, called [FFI](https://www.php.net/manual/en/book.ffi.php). It allows the loading of shared libraries (.dll or .so), calling of C functions and accessing of C data structures in pure PHP, without having to have deep knowledge of the Zend extension API, and without having to learn a third "intermediate" language.
 
-`Z-Engine` uses FFI to access internal structures of... PHP itself. This idea was so crazy to try, but it works! `Z-engine` loads definition of native PHP structures, like `zend_class_entry`, `zval`, etc and manipulates them in runtime. Of course, it is dangerous, since `FFI` allows to work with structures on a very low level. Thus, you should expect segmentation faults, memory leaks and other bad things. **DO NOT USE IT IN PRODUCTION UNTIL 1.0.0!**
+`Z-Engine` uses FFI to access internal structures of... PHP itself. This idea was so crazy to try, but it works! `Z-Engine` loads definition of native PHP structures, like `zend_class_entry`, `zval`, etc and manipulates them in runtime. Of course, it is dangerous, since `FFI` allows to work with structures on a very low level. Thus, you should expect segmentation faults, memory leaks and other bad things.
+
+**DO NOT USE IT IN PRODUCTION UNTIL 1.0.0!**
+
+Pre-requisites and initialization
+--------------
+
+As this library depends on `FFI`, it requires PHP>=7.4 and `FFI` extension to be enabled.
+It should work in CLI mode without any troubles, whereas for web mode `preload` mode should be implemented (not done yet), so please configure `ffi.enable` to be `true`.
+Also, current version is limited to x64 non-thread-safe versions of PHP.
+
+To install this library, simply add it via `composer`:
+```shell script
+composer require lisachenko/z-engine
+```
+
+Next step is to init library itself with short call to the `Core::init()`:
+```php
+use ZEngine\Core;
+
+include __DIR__.'/vendor/autoload.php';
+
+Core::init();
+```
+
+Now you can test it with following example:
+```php
+<?php
+declare(strict_types=1);
+
+use ZEngine\Reflection\ReflectionClass;
+
+include __DIR__.'/vendor/autoload.php';
+
+final class FinalClass {}
+
+$refClass = new ReflectionClass(FinalClass::class);
+$refClass->setFinal(false);
+
+eval('class TestClass extends FinalClass {}'); // Should be created
+```
+
+To have an idea, what you can do with this library, please see library tests as an example.
 
 ReflectionClass
 ------------
@@ -38,8 +80,8 @@ Library provides and extension for classic reflection API to manipulate internal
 
 Beside that, all methods that return `ReflectionMethod` or `ReflectionClass` were decorated to return an extended object with low-level access to native structures.
 
- ReflectionMethod
- ------------
+ReflectionMethod
+-------------
 
  `ReflectionMethods` contains methods to work with a definition of existing method:
 
@@ -52,4 +94,4 @@ Beside that, all methods that return `ReflectionMethod` or `ReflectionClass` wer
    - `setDeclaringClass(string $className): void` Changes the declaring class name for this method
    - `setDeprecated(bool $isDeprecated = true): void` Declares this method as deprecated/non-deprecated
    - `redefine(\Closure $newCode): void` Redefines this method with a closure definition
-   - `getOpCodes(): iterable`: \[WIP\] Returns list of opcodes for this method
+   - `getOpCodes(): iterable`: \[WIP\] Returns the list of opcodes for this method