Como emaranhar automaticamente outro bloco de origem para arquivo ao avaliar um bloco de origem no modo organizacional?

O bloco de origem que eu quero avaliar (src2) precisa originar um arquivo que deve ser o resultado do emaranhado de outro bloco de origem (src1). Como poderia fazer com que o emaranhado arquivasse automaticamente toda vez que avalio o bloco de origem?

src1: deve ser o emaranhado no arquivo:

+begin_src tcl :tangle /tmp/compile_lib.tcl
  <some tcl code>
+end_src

src2: seria avaliado.

+begin_src sh
   vivado -mode batch -source /tmp/compile_lib.tcl    # source the file tangled from <src1>
+end_src

Depois de olhar em volta, elaborei uma solução alternativa para fazer isso definindo uma variável fictícia para o src2bloco emaranhar o src1bloco.

Solução: 1. Primeiro, você deve nomear o src1bloco para facilitar a localização. 2. Crie uma variável dummy para usar elisp para emaranhar src1.

Código de exemplo:

#+NAME: my_hello
#+BEGIN_SRC emacs-lisp :tangle /tmp/hello.el
  (message "Hello")
#+END_SRC

#+BEGIN_SRC sh :var DUMMY=(progn (org-babel-goto-named-src-block "my_hello") (org-babel-tangle '(4))) :results output
  cat /tmp/hello.el
  rm -f /tmp/hello.el
#+END_SRC

#+RESULTS:
: (message "Hello")

Esta solução resolve meu problema por enquanto. Mas tem muitas limitações, como apenas o emaranhado do bloco no mesmo arquivo de modo organizacional.

Espero que alguns possam descobrir uma maneira melhor de fazê-lo.

Se você precisar de tudo para emaranhar em um único arquivo, poderá usar essa solução incrivelmente hacky que usa o orgmode para transformar uma tabela em código gerado em um segundo (ou terceiro!) Idioma.

Sua mesa (1):

#+tblname: personae-table
| Set | Description        | variable | Value |
|-----+--------------------+----------+-------|
| DEP | Fam Med Department | famDep   | 23    |

Seu gerador de código (2):

#+name: python-generate-new-and-set-vars-blocks
#+BEGIN_SRC python :var records=personae-table :exports results :results output verbatim drawer
  print("#+name: variables")
  print("#+BEGIN_SRC mumps")

  print("n " + ",".join(line[3] for line in records))
  print("s " +
        ",".join(
            "{}={}".format([line[2], str(line[3])]) for line in records))
  print()
  print("#+END_SRC")
#+END_SRC

Resultados do seu gerador (3):

#+results: python-generate-new-and-set-vars-blocks
:RESULTS:
#+name: variables
#+BEGIN_SRC mumps
n famDep
s famDep=23
#+END_SRC
:END:

Seu bloco fictício que pré-compila os blocos para emaranhar (4):

#+BEGIN_SRC emacs-lisp :tangle yes :var DUMMY=(progn (org-babel-goto-named-src-block "python-generate-new-and-set-vars-blocks") (org-ctrl-c-ctrl-c))
; run pre-tangle hooks by putting them in the var.
#+END_SRC

Seu bloco de saída que emaranha o código gerado (5):

#+BEGIN_SRC mumps :tangle fixed.m :noweb tangle :padline no
  run()
    <<variables>>
#+END_SRC

A execução é 4, 1, 2, 3, 5. Não tenho certeza se devo ter orgulho ou vergonha. Orgmode é incrível.