Helium, écriture d'un compilateur en python

# coding: utf-8

# In[DEBUT]:
'''
code    : declare code
        | expr code
        | import code
import  : methyl ident
        | helium ident
binding : carbon ident str
declare : dec ident = expr
funct   : def type ident ( argset block end
argset  : ident : type argset
        | )
type    : i
        | int
        | r
        | real
expr    : number
        | expr op expr
        | ident
        | alter
        | call
        | ifblock
        | whblock
        | { exprlist }
alter   : alt ident = expr
call    : ident ( exprset
        | expr : ident ( exprset
ifblock : if expr endif
endif   : expr else expr
        | expr
exprlist: expr exprlist
        | expr
whblock : while expr expr

'''

SRC = '''
methyl math

def i fac(n:i acc:i)
    if n>1
        fac(n-1 acc*n)
    else
        acc
end
def i pr(a:i b:i)
    print(a)
    print(b)
end

dec i = 1
while 1000 > fac(i 1)
    i = i + 1
pr(i fac(i 1))
dec j = -1

while j <= i {
    print(math!sin(j))
    j = j + 1
}
'''

#TODO:
# creer un systeme d'import base sur les fichier methyl :
## carbon : binding c
## helium : objet natif
# lire les fichier modules avant de passer a la phase de check pour
# enrichir la base de fonctions / variable ...
BASECODE = '''
// This code was generated by the Helium Compiler

//Import
#include <stdlib.h>
#include <stdio.h>
{0}
//Definition of functions
{1}
//Main code
int main(int argc, char** argv){{
{2}
    return 0;
}}
'''
METHYLCODE = '''
//**************** Methyl code ********************
//**************** {0}

{1}
{2}
/**************************************************/
'''
# In[Classes d'erreurs]:

# Types d'erreurs

class StandardError(Exception):
    def __init__(self, msg):
        self.msg = msg
    def __repr__(self):
        return self.msg

class LexingError(StandardError):
    pass

class ParsingError(StandardError):
    pass

class NameError_(StandardError):
    pass

class TypeError_(StandardError):
    pass


PRECTABLE = {'or':2,
             'and':5,
             '==':10, '!=':10,
             '>':20, '>=':20, '<':20, '<=':20,
             '+':30, '-':30,
             '*':40, '/':40,
             '**':50,
             ':':60 }

# In[Classes de token]:

# Classes des tokens

class Number:
    def __init__(self, val, ntype, pos=(0,0)):
        self.pos = pos
        self.val = val
        self.type = ntype
    def __repr__(self):
        return str(self.val)

class Key:
    def __init__(self, name, pos=(0,0)):
        self.pos = pos
        self.key = name
    def __eq__(self, other):
        return type(other) is Key and other.key == self.key
    def __repr__(self):
        return 'Key ' + self.key + ' at ' + str(self.pos)

class Ident:
    def __init__(self, name, pos=(0,0)):
        self.name = name
        self.pos = pos
        self.type = None
    def __eq__(self, other):
        return type(other) is Ident and other.name == self.name
    def __repr__(self):
        return '"' + self.name + '" at ' + str(self.pos)
    def __hash__(self):
        return (self.name).__hash__()

class Char:
    def __init__(self, char, pos=(0,0)):
        self.pos = pos
        self.char = char
    def __eq__(self, other):
        return type(other) is Char and other.char == self.char
    def __repr__(self):
        return '"' + self.char + '"' + ' at ' + str(self.pos)
class Op:
    def __init__(self, opcode, pos=(0,0)):
        self.code = opcode
        self.pos = pos
        self.prec = PRECTABLE[self.code]
    def __eq__(self, other):
        return type(other) is Op and other.code == self.code
    def __repr__(self):
        return 'Op ' + self.code + ' at ' + str(self.pos)

class Eof:
    def __eq__(self, other):
        return type(other) is Eof
    def __repr__(self):
        return 'EOF'

# In[Classe de noeud]:
# Constantes de descriptions
ALPHA = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
NUM = '0123456789'
BLANK = ' \t\n\r'
OPERATOR = ('or', 'and', '!=', '==', '>=', '<=', '<', '>', '+', '-',
        '*', '/', '**', '%', ':')
BEGOP = '!=><+-*/%oa:'
KEYWD = ('if', 'else', 'while', 'dec', 'alt', 'not', 'def', 'end',
            'methyl', 'helium', 'carbon')
TYPES = {Ident('i') : 'i', Ident('int') : 'i'
    , Ident('r') : 'r', Ident('real') : 'r'}
CTYPES = {'i' : 'int', 'r' : 'float'}
# Classes de l'AST

class Ast:
    def __init__(self):
        self.nodes = []
        self.c = -1

    def add(self, node):
        self.nodes.append(node)

class Function:
    def __init__(self, ident, args, define, outtype):
        self.ident = ident  #Ident
        self.args = args  #Ident list
        self.define = define  #block list
        self.scope = []
        self.type = [outtype]  #str list

    def __repr__(self):
        return 'def ' + self.ident.name

class Methyl:
    def __init__(self, filename):
        self.name = filename
        self.file = filename + '.ch3'
    def __repr__(self):
        return 'file ' + self.file

class Carbon:
    def __init__(self, name):
        pass

class Declare:
    def __init__(self, ident, val):
        self.ident = ident  #Ident
        self.val = val  #Expr
        self.type = None
    def __repr__(self):
        return 'declare ' + self.ident.name
class Alt:
    def __init__(self, ident, val):
        self.ident = ident  #Ident
        self.val = val  #Expr
        self.type = None
    def __repr__(self):
        return 'alt ' + self.ident.name

class BinExpr:
    def __init__(self, left, right, op):
        self.left = left
        self.right  = right
        self.op = op
        self.type = None
    def __repr__(self):
        return self.op.code

class Unary:
    def __init__(self, expr, mode):
        self.expr = expr
        self.mode = mode
        self.type = None
    def __repr__(self):
        return 'apply ' + self.mode

class If:
    def __init__(self, cond, exprif, exprelse = None):
        self.cond = cond  #Expr
        self.exprif = exprif  #Expr
        self.exprelse = exprelse  #Expr
        self.type = None
    def __repr__(self):
        return 'if'

class While:
    def __init__(self, cond, loop):
        self.cond = cond  #Expr
        self.loop = loop  #Expr
        self.type = None
    def __repr__(self):
        return 'while'

class Sequence:
    def __init__(self, exprs):
        self.exprs = exprs  #Expr[]
        self.type = None
    def __repr__(self):
        return str(self.exprs)

class Call:
    def __init__(self, name, args):
        self.ident = name  #Ident
        self.args = args  #Expr[]
        self.type = None
    def __repr__(self):
        return 'call of '+self.ident.name



# In[Lexer]:

# Lexer

class Lexer:
    def __init__(self, src):
        if src[-1] != '\n':
            self.src = src+'\n'
        else:
            self.src = src
        self.c = 0
        self.l = 1

    def count(self, nl=False):
        if nl:  #new line
            self.c = 0
            self.l += 1
        else:
            self.c += 1

    def pos(self):
        return self.c, self.l

    def tokenlist(self):
        t = None
        l = []
        while t != Eof():
            t = self.token()
            l.append(t)
        return l

    def token(self):
        if len(self.src) == 0:
            return Eof()
        c = ' '
        #Passer les blancs et les commentaires
        while c in BLANK:
            if not self.src:
                return Eof()
            c, self.src = self.src[0], self.src[1:]
            self.count(c=='\n')
        if c == '#':
            return self.lex_comment()
        if c in NUM or c == '.':
            return self.lex_nb(c)
        if c in ALPHA:
            return self.lex_id(c)
        if c in BEGOP:  #si c'est le premier caractere d'un operateur
            if c+self.src[0] in OPERATOR:
                op = c+self.src[0]
                self.count(self.src[0]=='\n')
                self.src = self.src[1:]
                return Op(op, self.pos())
            elif c in OPERATOR:
                return Op(c, self.pos())
        return Char(c, self.pos())

    def lex_comment(self):
        if len(self.src) == 0:
            return Eof()
        if self.src[0] == '*':
            level = 1
            while level:
                c, self.src = self.src[0], self.src[1:]
                if not self.src:
                    return Eof()
                if c == '*' and self.src[0] == '#':
                    level -= 1
                elif c == '#' and self.src[0] == '*':
                    level += 1
        else:
            c, self.src = self.src[0], self.src[1:]
            while c != '\n':
                c, self.src = self.src[0], self.src[1:]
                if not self.src:
                    return Eof()
        return self.token()

    def lex_id(self, first):
        '''
        [a-zA-Z_][a-zA-Z_0-9]*
        '''
        ident = ''
        c = first
        while (c in ALPHA or c in NUM) and len(self.src) > 0:
            ident += c
            c, self.src = self.src[0], self.src[1:]
            self.count()

        if len(self.src) != 0:
            self.src = c+self.src
        if ident in KEYWD:
            return Key(ident, self.pos())
        if ident in OPERATOR:
            return Op(ident, self.pos())
        return Ident(ident, self.pos())

    def lex_nb(self, nb):
        n = ''
        c = nb
        while (c in NUM or c == '.') and len(self.src) > 0:
            n += c
            c, self.src = self.src[0], self.src[1:]
            self.count()
        if len(self.src) != 0:
            self.src = c+self.src
        else:
            n += c
        dot = n.count('.')
        if dot == 0:
            t = 'i'
        elif dot == 1:
            t = 'r'
        else:
            raise LexingError('Too many "." in this number '+str(self.pos()))
        return Number(n, t, self.pos())

# In[Parser]:

# Parser

class Parser:
    def __init__(self, toklist):
        self.toklist = toklist
        self.tlen = len(self.toklist)
        self.cursor = 0
        self.types = []

    def tok(self, fail=0):
        'Passer au token suivant'
        if self.cursor < self.tlen - 1:
            self.cursor += 1
            return self.toklist[self.cursor]
        else :
            if fail:
                raise ParsingError('Unexpected end of file')
            return None

    def cur(self):
        'Token courant'
        return self.toklist[self.cursor]

    def nex(self):
        'Token suivant, permet l\'anticipation'
        if self.cursor < self.tlen - 1:
            return self.toklist[self.cursor +1]
        else :
            return None

    def parse(self):
        'Parser l\'ensemble d\'un fichier source'
        ast = Ast()
        block = self.parse_block()
        while block != None:
            ast.add(block)
            block = self.parse_block()
        return ast

    def parse_block(self, mode=0):
        'Parser un bloc a la racine du programme'
        if self.cur() == Eof():
            return None
        else:
            if self.cur() == Key('methyl'):
                 return self.parse_import()
            elif self.cur() == Key('helium'):
                raise ParsingError('Unimplemented option')
            elif self.cur() == Key('carbon'):
                raise ParsingError('Unimplemented option')
            elif self.cur() == Key('dec'):
                return self.parse_declare()
            elif self.cur() == Key('def'):
                if mode:
                    raise ParsingError('Function cannot be defined here : '
                            + str(self.cur().pos) )
                return self.parse_function()
            return self.parse_expr()

    def parse_expr(self):
        'Parser une expression'
        line = [self.parse_subexpr()]
        while type(self.cur()) == Op:
            line.append(self.cur())
            self.tok(1)
            line.append(self.parse_subexpr())
        return self.make_binexpr(line)

    def parse_subexpr(self):
        cur = self.cur()
        #Mots clés
        if cur == Key('if'):
            return self.parse_if()
        elif cur == Key('while'):
            return self.parse_while()
        #Liste d'expressions
        elif cur == Char('{'):
            self.tok(1)
            return self.parse_sequence()
        #Expressions paranthèsées
        elif cur == Char('('):
            self.tok(1)
            expr = self.parse_expr()
            if self.cur() != Char(')'):
                raise ParsingError('")" expected but ' + str(self.cur())
                    + ' found.')
            self.tok()
            return expr
        #Primitives
        elif type(cur) == Ident:
            nex = self.nex()
            if nex == Char('('):
                return self.parse_call()
            if nex == Char('='):
                return self.parse_alt()
            self.tok()
            return cur
        elif type(cur) == Number:
            self.tok()
            return cur
        #Operateurs unaires
        elif cur == Key('not'):
            self.tok(1)
            expr = self.parse_subexpr()
            return Unary(expr, 'not')
        elif cur == Op('-'):
            self.tok(1)
            expr = self.parse_subexpr()
            return Unary(expr, 'minus')
        #Echec
        raise ParsingError(str(cur)+' cannot be parsed as expression.')

    def parse_import(self):
        'Parser une importation de fichier methyl'
        cur = self.tok(1)
        self.tok()
        assert type(cur) == Ident, "Only identifier can be imported"
        return Methyl(cur.name)

    def parse_declare(self):
        'Parser une declaration de variable ou de fonction'
        cur = self.tok(1)
        if type(cur) != Ident:
            raise ParsingError(str(cur)+' cannot be an identifier.')
        ident = cur
        cur = self.tok(1)
        if cur != Char('='):
            raise ParsingError('Unexpected ' + str(self.nex()) + ' found.')
        self.tok(1)
        expr = self.parse_expr()
        return Declare(ident, expr)

    def parse_alt(self):
        'Parser un bloc alt'
        cur = self.cur()
        if type(cur) != Ident:
            raise ParsingError(str(cur)+' cannot be an identifier.')
        ident = cur
        cur = self.tok(1)
        if cur == Char('='):
            self.tok(1)
            expr = self.parse_expr()
            return Alt(ident, expr)
        elif cur == Char('['):
            pass
        else:
            raise ParsingError('Unexpected ' + str(cur) + ' found.')

    def parse_function(self):
        'Parser une declaration de variable ou de fonction'
        cur = self.tok(1)
        outtype = self.parse_type()
        cur = self.tok(1)
        if type(cur) != Ident:
            raise ParsingError(str(cur)+' cannot be used as function name.')
        ident = cur
        cur = self.tok(1)
        if cur != Char('('):
            raise ParsingError('Unexpected ' + str(cur) + ' found.')
        args = []
        cur = self.tok(1)

        while cur != Char(')'):
            if type(cur) != Ident:
                raise ParsingError('Identifier expected but ' + str(cur)
                    + ' found.')
            arg = cur
            if self.tok(1) != Op(':'):
                raise ParsingError('":" expected but ' + str(self.cur())
                    + ' found.')
            cur = self.tok(1)
            arg.type = self.parse_type()  #give a type to the argument
            args.append(arg)
            cur = self.tok(1)

        self.tok(1)
        define = []
        while self.cur() != Key('end'):
            define.append(self.parse_block(1))
        self.tok()
        return Function(ident, args, define, outtype)

    def parse_type(self):
        cur = self.cur()
        if cur not in TYPES and cur not in self.types:
            raise ParsingError(str(cur) + ' is not a type name.')
        
        else: #type(cur) == Ident
            return TYPES[cur]

    def parse_if(self):
        'Parser un bloc if'
        self.tok(1)
        cond = self.parse_expr()
        eif = self.parse_expr()
        if self.cur() == Key('else'):
            self.tok(1)
            eelse = self.parse_expr()
            return If(cond, eif, eelse)
        return If(cond, eif)

    def parse_while(self):
        'Parser un bloc while'
        self.tok(1)
        cond = self.parse_expr()
        loop = self.parse_expr()
        return While(cond, loop)

    def parse_call(self):
        'Parser un appelle de fonction'
        ident = self.cur()
        self.tok(1)
        self.tok(1)
        args = []
        while self.cur() != Char(')'):
            args.append(self.parse_expr())  # (expr, exprtype)
        self.tok()
        return Call(ident, args)


    def parse_sequence(self):
        'Parser une sequence d\'expression'
        exprs = []
        while self.cur() != Char('}'):
            exprs.append(self.parse_expr())
        self.tok()
        return Sequence(exprs)

    def make_binexpr(self, line):
        if len(line) == 1:
            return line[0]
        m = 1  #indice de l'operateur le moins prioritaire
        #on cherche l'operateur avec la plus petite priorité
        #A priorité egale on prend le plus à gauche sauf dans le cas de :
        #(operateur d'espace de nom)
        for i in range(3,len(line),2):
            if line[i].prec <= line[m].prec:
                if line[i].prec == line[m].prec and line[i].op == ":":
                    continue # on saute l'instruction m = i
                m = i

        left = self.make_binexpr(line[:m])
        right = self.make_binexpr(line[m+1:])
        op = line[m]
        return BinExpr(left,right,op)



# In[Checker]:


# Checker : Verifie la coherence de la source

class Checker:
    instance = -1
    CH3 = 1
    def __init__(self, basefunctable, basevartable, ast, name = '_main'):
        self.name = name
        self.ast = ast
        self.vartable = basevartable.copy()
        self.functable = basefunctable.copy()
        self.moduletable = {}
        self.localtable = [{}]
        Checker.instance += 1

    def check(self):
        for block in self.ast.nodes:
            t = type(block)
            if t == Declare:
                self.check_declare(block)
            elif t == Function:
                self.check_function(block)
            elif t == Methyl:
                self.check_methyl(block)
            else:
                block.type = self.check_expr(block)
            
        self.ast.scope = self.localtable[-1]
        return self.localtable[-1]


    def check_expr(self, b):
        t = type(b)
        if t == Number:
            return b.type
        elif t == Ident:
            return self.check_ident(b)
        elif t == BinExpr:
            return self.check_binexpr(b)
        elif t == Unary:
            return self.check_expr(b.expr)
        elif t == If:
            return self.check_if(b)
        elif t == While:
            return self.check_while(b)
        elif t == Call:
            return self.check_call(b)
        elif t == Sequence:
            return self.check_sequence(b)
        elif t == Alt:
            return self.check_alt(b)
        else:
            raise ParsingError('What the fuck !! '+str(b))

    def check_declare(self, b):
        t = self.check_expr(b.val)
        self.localtable[-1][b.ident.name] = t
        b.type = t

    def check_function(self, b):
        #on ajoute la fonction elle même (pour les appel récursif)
        self.functable[b.ident.name] = (Checker.instance, b.type)
        #on duplique la table locale
        self.localtable.append(self.localtable[-1])
        #on ajoute les arguments
        for ident in b.args:
            self.localtable[-1][ident.name] = ident.type
            b.type.append(ident.type)

       #on garde l'état du scope dans la fonction pour la compilation
        b.scope = self.localtable[-1]
        #on check la definition
        for block in b.define:
            t = type(block)
            if t == Declare:
                self.check_declare(block)
            else:
                self.check_expr(block)
        #on supprime la table locale
        print(self.localtable)
        self.localtable.pop()
        print(self.localtable)
    
    def check_methyl(self, b):
        'check l\'ensemble du fichier en question et ajoute les objets et fonction a la base de donnees'
        s = ''
        with open(b.file, 'r') as f:
            s = f.read()
        if s == '':
            raise 'File cannot be found or is empty'
        
        locpars = Parser(Lexer(s).tokenlist())
        locast = locpars.parse()
        loccheck = Checker(basefunctable, basevartable, locast, b.name)
        self.moduletable[b.name] = loccheck.check()
        self.functable.update(loccheck.functable)
        self.localtable[-1].update(loccheck.localtable[-1])
        print(loccheck.localtable[-1])
        locchainer = Chainer(locast)
        locchainer.chain_all()
        compiler = Compiler(basefunctable, basevartable, locchainer.chain,b.name )
        ccode = compiler.comp(locchainer.chain)
        with open(b.name + '.c', 'w') as f:
            f.write(ccode)

    def check_alt(self, b):
        t = self.check_expr(b.val)
        b.type = t
        name = b.ident.name
        if name in self.vartable:
            if t != self.vartable[name]:
                raise TypeError_('Wrong type for ' + str(b))
        elif name in self.localtable[-1]:
            if t != self.localtable[-1][name]:
                raise TypeError_('Wrong type for ' + str(b))
        else:
            raise NameError_('Unknown identifier '+str(b))
        return t

    def check_ident(self, b):
        if b.name in self.vartable:
            b.type = self.vartable[b.name]
        elif b.name in self.localtable[-1]:
            b.type = self.localtable[-1][b.name]
        elif b.name in self.moduletable:
            b.type = b.name
        else:
            raise NameError_('Unknown identifier '+str(b))
        return b.type

    def check_funcident(self, b, tpar):
        if b.name in self.functable:
            return self.functable[b.name][1]
        elif tpar is not None and b.name in self.moduletable[tpar]:
            return self.moduletable[tpar][b.name][1]
        raise NameError_('Unknown identifier '+str(b))

    def check_binexpr(self, b):
        
        tl = self.check_expr(b.left)
        if b.op == Op(':'):
            return self.check_call(b.right, tl)

        tr = self.check_expr(b.right)
        if b.op == Op('**'):
            if tl not in ('i', 'r') or tr not in ('i', 'r'):
                raise TypeError_('Both expressions have to be number '
                    + str(b.op.pos))
            b.type = 'r'
            return 'r'
        else:
            if tl != tr:
                raise TypeError_('Both expressions have to have the same type '
                    + str(b.op.pos))
            b.type = tl
            return tl

    def check_if(self, b):
        self.check_expr(b.cond)
        t = self.check_expr(b.exprif)
        if b.exprelse:
            if t != self.check_expr(b.exprelse):
                raise TypeError_('if and else blocks have to have the same type ' + b.pos())
        b.type = t
        return t

    def check_while(self, b):
        self.check_expr(b.cond)
        t = self.check_expr(b.loop)
        b.type = t
        return t

    def check_call(self, b, tparent=None):
        t = self.check_funcident(b.ident, tparent)
        for i in range(len(b.args)):
            targ = self.check_expr(b.args[i])
            if t[i+1] != targ:
                raise TypeError_('Wrong type in '+str(b))
        if tparent is not None and tparent != t[-1]:
            raise TyperError_(tparent + ' has not ' + b.ident + ' method')
        b.type = t[0]
        return t[0]

    def check_sequence(self, b):
        for expr in b.exprs:
            t = self.check_expr(expr)
        b.type = t
        return t


# In[Chainer]:

class Chain:
    def __init__(self):
        self.nodes = []

    def add(self, other):
        if type(other) == Chain:
            self.nodes += other.nodes
        else:
            self.nodes.append(other)

    def pop(self, val):
        if self.nodes[-1] == val:
            del self.nodes[-1]
    def __repr__(self):
        return str(self.nodes)

class Chainer:
    def __init__(self, ast):
        self.ast = ast
        self.chain = Chain()

    def chain_all(self):
        'Chainer l\'ensemble de l\'ast'
        for node in self.ast.nodes:
            t = type(node)
            if t == Declare:
               self.chain_declare(node)
            elif t == Function:
                self.chain_function(node)
            elif t == Methyl:
                self.chain.add(('methyl', node.name))
            else:
                self.chain_expr(node)
                self.chain.add(('flevel',))

    def chain_function(self, node):
        self.chain.add(('function', node.ident.name
            , [ arg.name for arg in node.args], node.type))
        for block in node.define:
            if type(block) == Declare:
               self.chain_declare(block)
            else:
                self.chain_expr(block)
                self.chain.add(('flevel',))
        self.chain.pop(('flevel',))
        self.chain.add(('endfunc',))

    def chain_declare(self, node):
        self.chain_expr(node.val)
        node.val = None
        self.chain.add(('declare',node.ident.name, node.type))

    def chain_alt(self, node):
        self.chain_expr(node.val)
        node.val = None
        self.chain.add(('alt',node.ident.name))

    def chain_expr(self, node):
        t = type(node)
        if t == Number:
            self.chain.add(('number', node.val))
        elif t == Ident:
            self.chain.add(('ident', node.name))
        elif t == BinExpr:
            self.chain_binexpr(node)
        elif t == Unary:
            self.chain_expr(node.expr)
            self.chain.add(('unary', node.mode))
        elif t == If:
            self.chain_if(node)
        elif t == While:
            self.chain_while(node)
        elif t == Call:
            self.chain_call(node)
        elif t == Sequence:
            self.chain_sequence(node)
        elif t == Alt:
            self.chain_alt(node)
        elif t == Array:
            self.chain_array(node)
        else:
            raise ParsingError('What the fuck ?! '+str(node))

    def chain_binexpr(self, node):
        self.chain_expr(node.right)
        self.chain_expr(node.left)
        self.chain.add(('binexpr', node.op.code))

    def chain_if(self, node):
        self.chain_expr(node.cond)
        #On empile le node if avant les expression a evalué pour
        #compilé de façon adapté
        self.chain.add(('if',node.type))
        self.chain_expr(node.exprif)
        if node.exprelse:
            # pseudo node pour marquer le changement
            self.chain.add(('else',))
            self.chain_expr(node.exprelse)
        # pseudo node pour marquer la fin du block
        self.chain.add(('endblock',))

    def chain_while(self, node):
        # la demarche est exactement la meme que pour le if
        self.chain_expr(node.cond)
        self.chain.add(('while',node.type))
        self.chain_expr(node.loop)
        self.chain.add(('endblock',))

    def chain_call(self, node):
        for arg in node.args:
            self.chain_expr(arg)
        self.chain.add(('call', node.ident.name, len(node.args)))

    def chain_sequence(self, node):
        for i in range(len(node.exprs)-1):
            self.chain_expr(node.exprs[i])
            #pseudo node, marque la limite entre deux membres d'une sequence
            self.chain.add(('seqsep',))
        self.chain_expr(node.exprs[-1])
# In[Compiler]:

def makeC(op):
    if op == 'or':
        return '||'
    elif op == 'and':
        return '&&'
    elif op == 'minus':
        return '-'
    elif op == 'not':
        return '!'
    return op

def makeCtype(t):
    return CTYPES[t]

# Compiler

class Compiler:
    def __init__(self, basefunctable, basevartable, chain, name = '_main'):
        self.name = name
        self.chain = chain
        self.vartable = basevartable.copy()
        self.functable = basefunctable.copy()
        self.localtable = [[]]
        self.mode = 0 #0 maincode 1 funcode/methylcode
        self.indent = 1
        self.imp = set()
        self.importcode = ''
        self.funcode = ''
        self.maincode = ''
        self.stack = []
        self.blocknb = 0
        self.blockres = ''

    def push(self, var):
        self.stack.append(var)

    def pop(self):
        return self.stack.pop()

    def cntblock(self):
        self.blockres = 'B_' + str(self.blocknb)
        self.blocknb += 1

    def write(self, code, offset=0):

        if self.mode:
            self.funcode += '    '*(self.indent+offset-1) + code
        else:
            self.maincode += '    '*(self.indent+offset-(self.name != '_main')) + code

    def make_import(self):
        for m, file in self.imp:
            if m == 0 :
                self.importcode += '#include <' + file + '>\n'
            else:
                self.importcode += '#include "' + file + '"\n'

    def comp(self, chain):
        for node in chain.nodes:
            t = node[0]
            if t == 'declare':
                self.comp_declare(node)
            elif t == 'function':
                self.mode = 1 
                self.comp_function(node)
            elif t == 'methyl':
                self.imp.add((1, node[1] + '.c'))
            #pseudo node
            elif t == 'else':
                self.write(self.blockres + ' = ' + self.pop() + ';\n')
                self.write('}else{\n', -1)
            elif t == 'endblock':
                self.write(self.blockres + ' = ' + self.pop() + ';\n')
                self.push(self.blockres)
                self.indent -= 1
                self.write('}\n')
            elif t == 'endfunc':
                self.write('return {};\n'.format(self.pop()))
                self.indent -= 1
                self.write('}\n')
                self.mode = 0
            elif t == 'begar':
                self.push('{')
            elif t == 'endar':
                a = self.pop()
                b = self.pop()
                self.push(b + a + '}')
            elif t == 'seqsep':
                self.write(self.pop() + ';\n')
            elif t == 'arsep':
                a = self.pop()
                b = self.pop()
                self.push(b + a + ',')
            elif t == 'flevel':
                self.write(self.pop() + ';\n')
            #expr
            else:
                self.comp_expr(node)
        self.make_import()
        if self.name != '_main':
            return METHYLCODE.format(self.name, self.funcode, self.maincode)
        return BASECODE.format(self.importcode, self.funcode, self.maincode)

    def comp_expr(self, node):
        t = node[0]
        if t == 'number':
            self.push(node[1])
        elif t == 'ident':
            self.push(node[1])
        elif t == 'binexpr':
            self.comp_binexpr(node)
        elif t == 'unary':
            self.push(makeC(node[1]) + self.pop())
        elif t == 'if':
            self.comp_if(node)
        elif t == 'while':
            self.comp_while(node)
        elif t == 'call':
            self.comp_call(node)
        elif t == 'alt':
            self.comp_alt(node)

    def comp_declare(self, node):
        self.write('{} {} = {};\n'.format(makeCtype(node[2]), node[1], self.pop()))

    def comp_function(self, node):
        code = '{} {} ('.format(makeCtype(node[3][0]), node[1])
        for arg,t in zip(node[2],node[3][1:]):
            code += '{} {},'.format(makeCtype(t), arg)
        self.write(code[:-1] + '){\n')
        self.indent += 1

    def comp_alt(self, node):
        self.write('{} = {};\n'.format(node[1], self.pop()))
        self.push(node[1])

    def comp_call(self, node):
        if node[1] in basefunctable:
            call = ' )'
            for i in range(node[2]):
                call = ', ' + self.pop() + call
            call = basefunctable[node[1]][0] + call[2:]
            self.push(call)
        else:
            call = ' )'
            for i in range(node[2]):
                call = ', ' + self.pop() + call
            call = node[1] + '( ' + call[2:]
            self.push(call)

    def comp_binexpr(self, node):
        l, r = self.pop(), self.pop()
        if node[1] == '**':
            self.imp.add((0, 'math.h'))
            self.push('pow( {}, {} )'.format(l, r))
        else:
            self.push(l + ' ' + makeC(node[1]) + ' ' + r)

    def comp_if(self, node):
        self.cntblock()
        self.write('//block ' + str(self.blockres) + '\n')
        self.write('{} {} = 0;\n'.format(makeCtype(node[1]), self.blockres))
        self.write('if( {} ){{\n'.format(self.pop()))
        self.indent += 1

    def comp_while(self, node):
        self.cntblock()
        self.write('//block ' + str(self.blockres) + '\n')
        self.write('{} {} = 0;\n'.format(makeCtype(node[1]), self.blockres))
        self.write('while( {} ){{\n'.format(self.pop()))
        self.indent += 1

# In[Test]:
# basefunctable :
#  contenu --> nom helium : (code C, [type out, type arg1,...])
basefunctable = {'print': (r'printf("%i\n", ',['i','i'])}
basevartable = {}
from sys import argv, stdin, setrecursionlimit

setrecursionlimit(100)

if len(argv) > 1:
    if argv[-1] == "-":
        SRC = stdin.read()
    else:
        with open(argv[-1]) as f:
            SRC = f.read()

    parser = Parser(Lexer(SRC).tokenlist())
    ast = parser.parse()
    checker = Checker(basefunctable, basevartable, ast)
    checker.check()
    chainer = Chainer(ast)
    chainer.chain_all()


    compiler = Compiler(basefunctable, basevartable, chainer.chain)

    print(compiler.comp(chainer.chain))
else:
    print("Usage :")
    print("\t" + argv[0] + " [infile][-]")

Operation :
[op] [type] arg1, arg2
  [op] binaire :
      shl
      ashr
      lshr
      and
      or
      xor
  [op] pour [type] = iXX :
      mul
      add
      sub
      sdiv # s signed, u unsigned
      udiv
      urem # reminder 
      srem
  [op] pour [type] = float/double :
      fmul
      fadd
      fsub
      fdiv
      frem 

Variable
  %name = alloca [type]
  store [type] [valeur], [type]* %name
Tableau
  Creation
      %name = alloca [size x type]
  Modification d'une case (name[offset] en C)
      %1 = getelementptr inbounds [size x type]* %name, i32 0, i64 [offset]
      store [type] 1, [type]* %1

Cast
  Int en Char
      %2 = trunc i32 %1 to i8
  Char en Int signé
      %2 = sext i8 %1 to i32
  Char en Int non signé
      %2 = zext i8 %1 to i32
  Double en Float
      %2 = fptrunc double %1 to float
  Float en Double
      %5 = fpext float %4 to double
  entier signé en flottant
      %2 = sitofp/uitofp iXX %1 to double/float
  flottant en entier
      %2 = fptosi/fptoui float/double %1 to iXX

Saut inconditionel
  br label %lab
  ...
  lab:
      ...

Saut conditionel
  br i1 <cond>, label %labif, label %labelse
  ...
  labif:
      ...
  labelse:
      ...

// This code was generated by the Helium Compiler

//Import
#include "helium.h"

//

x//Definition of functions
float fac(float n,float acc){
    Elem * top = NULL;
    PUSH(1);
    PUSH(n);
    PUSH(POP()>POP());
    if(POP()){
        PUSH(1);
        PUSH(n);
        PUSH(POP()-POP());
        PUSH(n);
        PUSH(acc);
        PUSH(POP()*POP());
        PUSH(fac(POP(),POP()));
    }else{
        PUSH(acc);
    }
    float res = POP();
    freestack(top);
    return res;
}

//

//Main code
int main(int argc, char** argv){
    Elem * top = NULL;
        PUSH(1);
    float i = POP();
    PUSH(i);
    PUSH(1);
    PUSH(fac(POP(),POP()));
    PUSH(1000);
    PUSH(POP()>POP());
    while(POP()){
        PUSH(1);
        PUSH(i);
        PUSH(POP()+POP());
        i = POP();
        PUSH(i);
        PUSH(1);
        PUSH(fac(POP(),POP()));
        PUSH(1000);
        PUSH(POP()>POP());
    }
    PUSH(i);
    PUSH(print(POP()));

    freestack(top);
    return 0;
}

// This code was generated by the Helium Compiler

//Import
#include <stdlib.h>
#include <stdio.h>

//

//Definition of functions
float fac(float n,float acc){
    //block B_0
    float B_0 = 0;
    if( n > 1 ){
        B_0 = fac( n - 1, acc * n );
    }else{
        B_0 = acc;
    }
    return B_0;
}

//

//Main code
int main(int argc, char** argv){
    float i = 1;
    //block B_1
    float B_1 = 0;
    while( 1000 > fac( i, 1 ) ){
        i = i + 1;
        B_1 = i;
    }
    printf("%f\n", i );

    return 0;
}