Comment ajouter des capacités de trace / de débogage à une langue mise en œuvre à Python?

Question

J'utilise Python pour mettre en œuvre un autre langage de programmation nommé 'FOO'. Tout le code de FOO sera traduit en Python et sera également exécuté dans le même interprète Python, de sorte que cela se traduira par Python.

Voici un petit morceau de code de FOO:

function bar(arg1, arg2) {
    while (arg1 > arg2) {
        arg2 += 5;
    }
    return arg2 - arg1;
}

qui va traduire en:

def _bar(arg1, arg2):
    while arg1 > arg2:
        arg2 += 5
        watchdog.switch()
    watchdog.switch()
    return arg2 - arg1

Le 'WatchDog' est une greenlet (le code généré est également en cours d'exécution dans un contexte de greenlet) qui surveillera / limiter l'utilisation des ressources, car la langue sera exécutée de code non approuvé.

Comme on peut le voir dans l'exemple, avant que le code Python ne soit généré, de petites modifications seront apportées à l'arborescence d'analyse afin d'ajouter des commutateurs de surveillance et d'apporter de petites modifications aux identifiants de fonction.

Pour répondre à tous les demandes de requériments, je dois également ajouter des capacités de trace / de débogage à la langue, de sorte que lorsque le temps d'exécution Python jette une exception, ce que l'utilisateur verra est la trace de code de FOO (comme ope à l'affichage de la traçabilité générée par le code Python. ).

Considérez que l'utilisateur crée un fichier nommé 'programme.foo' avec le contenu suivant:

1  function bar() {
2      throw Exception('Some exception message');
3  }
4
5  function foo() {
6      output('invoking function bar');
7      bar();
8  }
9
10 foo();

qui va traduire en:

def _bar():
    watchdog.switch()
    raise Exception('Some exception message')

def _foo():
    print 'invoking function bar'
    watchdog.switch()
    _bar()

watchdog.switch()
_foo()

Ensuite, la sortie de 'programme.foo' devrait être quelque chose comme:

invoking function bar
Traceback (most recent call last):
  File "program.foo", line 10
    foo();
  File "program.foo", line 7, inside function 'foo'
    bar();
  File "program.foo", line 2, inside function 'bar'
    throw Exception('Some exception message');
Exception: Some exception message

Y a-t-il un moyen facile de faire ça? Je préférerais une solution qui n'implique pas l'instrumentation de Python Bytecode, car elle est interne à la mise en œuvre de l'interprète, mais s'il n'y a rien d'autre, alors l'instrumentation de l'instrumentation le fera également.

Answer 1

You could decorate each generated Python function with a decorator which record the context (filename, function, line number, etc.) to a global stack. Then you could derive your own Exception class and catch it at the top level of the interpreter. Finally, you print out what you like, using information from the global debug stack.