BTAG is used for producing text and is Object Oriented.
The TAG stands for Tag.
There are several kind of tags:
a) The text tag
b) The lines tag
c) The code tag
d) The concat tag
e) The concatcode tag
f) The split tag also named Class

Normal usage of a tag is:
([name] [text|lines|code|concat|concatcode|split

)

a) The text tag
    A definition of text. When printed lines will be
    put after eachother seperated by character space.
    The beginning whitespace characters will be removed.
b) The lines tag
    Lines will be put after eachother
c) The code tag
    Lines will be put as is
d) The concat tag
    Lines will be put after eachother with no seperation
e) The concatcode tag
    Lines will be put after eachother with no seperation
    The beginning whitespace characters will not be removed.
f) The split tag also named Class
    Exists of many commands and will be further explained.

All tags except the Split Tag will start in rpublic


The Split tag:

usage:
([name] split

)

or

Class [name]
{

}

There are several commands for split:
a) use                  For calling another command
b) line                 Produces output
c) text                 Produces output
d) uselist              For calling other commands
e) inherit              For inheriting
f) filenew              Opens a new file
g) fileappend           Opens a file to append to it
h) usearound            Calling other commands
i) code                 Produces output
j) fileclose            Closes a file
k) filenewreopen        Reopens a file (deleting the previous)
l) fileappendreopen     Reopens a file for appending
m) concat               Produces output
n) concatcode           Produces output
o) usefile              Indicate to us a file
p) system               Call a system procedure
q) procedure            A definition of a procedure
r) function             A definition of a function
s) private              To set the next commands private
t) protected            To set the next commands protected 
u) public               To set the next commands public
v) rpublic              To set the next commands rpublic

a) use             
    Syntax: use [name] [command]
    command can be:
    1) an inherited command: .name
        will look to upper level (public and rpublic)
        and then this (all) and then lower
        using the inherit block (protected and public and rpublic)
    2) a command in himself: this.name
        will look only in himself (all)
    3) a command somewhere else: Classname.name
        will look somewhere else (public and rpublic)
    4) a Class name: Classname
        will run the rpublic commands
        
b) line
    Syntax: line [name] 
    
c) text
    Syntax: 
    text [name]
       
    .
         
d) uselist         
    Syntax:
    uselist [name]
        
    .
    
e) inherit         
    Syntax:
    inherit 
        
    .
    
f) filenew         
    Syntax: filenew [name] [filename inside "..."]
    
g) fileappend
    Syntax: fileappend [name] [filename inside "..."]
    
h) usearound       
    Syntax: 
        usearound [name] [what to use]
        
        .
    will use the "begin" and "end" names of what to use to
    put this around the commands.
    
i) code            
    Syntax: 
        code [name]
        
        .
        
j) fileclose
    Syntax: fileclose [name]
    
k) filenewreopen   
    Syntax: filenewreopen [name]
    
l) fileappendreopen
    Syntax: fileappendreopen [name]
    
m) concat          
    Syntax:
        concat [name]
        
        .
        
n) concatcode      
    Syntax:
        concatcode [name]
        
        .
        
o) usefile         
    Syntax: usefile [name] [name to use]
    
p) system          
    Syntax: system [name] ["System command"]
    
q) procedure       
    Syntax:
        procedure [name]()
        {
            
        }
r) function (later)
        Syntax:
        function [name]() : [type to return]
        {
            
        }

s) private
    Syntax: private
    This is an pre-compiler statement
    
t) protected       
    Syntax: protected
    This is an pre-compiler statement

u) public          
    Syntax: public
    This is an pre-compiler statement

v) rpublic         
    Syntax: rpublic
    This is an pre-compiler statement


The first syntax I've use for commands is that
all commands begins with a dot. It also works.


Explanation of the encapsulation

public: All classes can access these commands
protected: Only himself and inherited classes have access
private: Only himself has access
rpublic: Commands for execution

Explanation of inheritance

Inheritance is declarated by the command inherit
The engine will search downwards in this list 
to find a commmand that can be used.
By default this command is protected.
All other commands are privated by default.

The beginning for a program

Programs always start with the Class called main.
There has to be a rpublic commands defined to have
something to execute.