# -*- coding: utf-8 -*-
# :-
# SPDX-FileCopyrightText: © 2015 Simon Wachter
# SPDX-FileCopyrightText: © 2026 Franz Glasner
# SPDX-License-Identifier: MIT
# :-
r"""
:Author:    Simon Wachter
:Author:    Franz Glasner
:Copyright: © 2015 Simon Wachter
:Copyright: © 2026 Franz Glasner
:License:   MIT License.
            See :file:`MIT.txt` for details.
            If you cannot find MIT.txt see
            <http://opensource.org/licenses/MIT>.
"""

__version__ = "2.0.1"

__all__ = ["PseudocodeLexer2"]


import re

from pygments.lexer import RegexLexer, include, bygroups, using, this
from pygments.token import Error, Punctuation, Text, Comment, Operator, Keyword, Name, String, Number


class PseudocodeLexer2(RegexLexer):
    '''
    A Pseudo code (fr) lexer
    '''
    name = 'Pseudocode'
    aliases = ['pseudocode', 'pseudo', 'algorithm', 'algo']
    filenames = ['*.algo', '*.pseudocode']
    mimetypes = []
    flags = re.IGNORECASE

    REPLACEMENTS = {
        '<=': '≤',
        '>=': '≥',
        '<>': '≠',
        '!=': '≠',
        '<-': '←',
        '->': '→',
        '=>': '⇒',
        '^': '↑',
    }

    def op_replace(lexer, match):
        op = match.group(0)
        opr = lexer.REPLACEMENTS.get(op)
        if opr is None:
            yield match.start(), Operator, op
        else:
            yield match.start(), Operator, opr

    def scomment(lexer, match):
        s = match.group(1).lower().strip()
        c = Comment

        directives = ['passage par copie', 'passage par valeur', 'passage par référence', 'passage par reference', 'passage par adresse', 've', 'vs', 've/s']

        if s in directives:
            c = Comment.Special

        yield match.start(), c, match.group(0)

    tokens = {
        'root': [
                 (r'\/\*.*\*\/', Comment),
                 (r'(\/\/|#).*\n', Comment),
                 (r'\|', Comment),
                 (r'\{(.*)\}', scomment),
                 include('strings'),
                 include('core'),
                 (r'[a-zéàùçèÉÀÙÇÈ][a-z0-9éàùçèÉÀÙÇÈ_]*', Name.Variable),
                 include('numbers'),
                 (r'[\s]+', Text)
        ],
        'core':[ # Statements
                 (r'\b(debut|début|fin|si|alors|sinon|fin[_ ]si|tant[ _]que|tantque|fin[ _]tantque|faire|répéter'
                  r'repeter|type|structure|fin[ _]structure|fonction|procédure|procedure|retourner|renvoyer|'
                  r'pour|fin[ _]pour|à|déclarations?|juqsque|spécialise|specialise|comporte|super|public|privé|protégé|'
                  r'classe'
                  r')\s*\b', Keyword),

                 # Data Types
                 (r'\b(entiers?|chaines?|chaînes?|réels?|reels?|caractères?|caracteres?|booléens?|'
                  r'booleens?|tableaux?|rien)\s*\b',
                  Keyword.Type),

                  (r'\b(vrai|faux|nil)\s*\b',
                   Name.Constant),

                 # Operators
                 (r'(<=|>=|<>|!=|<-|->|=>|\^|\*|\+|-|\/|<|>|=|\\\\|mod|←|↑|≤|≥|≠|÷|×|\.\.|\[|\]|\.|non|xou|et|ou)',
                  op_replace),

                 (r'(\(|\)|\,|\;|:)',
                  Punctuation),

                 #(r'\b(\[(VE|VS|VE/S)\])\s*\b',
                 # Keyword.Declaration),

                  # Intrinsics
                 (r'\b(sqrt|pow|cos|sin|tan|arccos|arcsin|arctan|arctan2|lire|ecrire|écrire|'
                  r'exp|ln|log|détruire|detruire'
                  r')\s*\b', Name.Builtin)
                ],

        'strings': [
                 (r'"([^"])*"', String.Double),
                 (r"'([^'])*'", String.Single),
                ],
#        
# This is stolen from the Pygment's Python lexer.
#
# SPDX-SnippetBegin
# SPDX-License-Identifier: BSD-2-Clause
# SPDX-SnippetCopyrightText: Copyright 2006-2023 by the Pygments team
        'numbers': [
            (r'(\d(?:_?\d)*\.(?:\d(?:_?\d)*)?|(?:\d(?:_?\d)*)?\.\d(?:_?\d)*)'
             r'([eE][+-]?\d(?:_?\d)*)?', Number.Float),
            (r'\d(?:_?\d)*[eE][+-]?\d(?:_?\d)*j?', Number.Float),
            (r'0[oO](?:_?[0-7])+', Number.Oct),
            (r'0[bB](?:_?[01])+', Number.Bin),
            (r'0[xX](?:_?[a-fA-F0-9])+', Number.Hex),
            (r'\d(?:_?\d)*', Number.Integer),
        ],
# SPDX-SnippetEnd
        }