Skip to content
Snippets Groups Projects
Select Git revision
  • 6d44c5b577be5d55320b4a7f4e2668dec2293f5c
  • develop default protected
  • feature/variational-hydro
  • origin/stage/bouguettaia
  • feature/gmsh-reader
  • feature/reconstruction
  • save_clemence
  • feature/kinetic-schemes
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

GmshReader.cpp

Blame
  • ob-pugs.el 7.87 KiB
    ;;; ob-pugs.el --- org-babel functions for pugs evaluation
    
    ;; Copyright (C) your name here
    
    ;; Author: your name here
    ;; Keywords: literate programming, reproducible research
    ;; Homepage: https://orgmode.org
    ;; Version: 0.01
    
    ;;; License:
    
    ;; This program is free software; you can redistribute it and/or modify
    ;; it under the terms of the GNU General Public License as published by
    ;; the Free Software Foundation; either version 3, or (at your option)
    ;; any later version.
    ;;
    ;; This program is distributed in the hope that it will be useful,
    ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
    ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ;; GNU General Public License for more details.
    ;;
    ;; You should have received a copy of the GNU General Public License
    ;; along with GNU Emacs; see the file COPYING.  If not, write to the
    ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    ;; Boston, MA 02110-1301, USA.
    
    ;;; Commentary:
    
    ;; This file is not intended to ever be loaded by org-babel, rather it is a
    ;; pugs for use in adding new language support to Org-babel. Good first
    ;; steps are to copy this file to a file named by the language you are adding,
    ;; and then use `query-replace' to replace all strings of "pugs" in this
    ;; file with the name of your new language.
    
    ;; After the `query-replace' step, it is recommended to load the file and
    ;; register it to org-babel either via the customize menu, or by evaluating the
    ;; line: (add-to-list 'org-babel-load-languages '(pugs . t)) where
    ;; `pugs' should have been replaced by the name of the language you are
    ;; implementing (note that this applies to all occurrences of 'pugs' in this
    ;; file).
    
    ;; After that continue by creating a simple code block that looks like e.g.
    ;;
    ;; #+begin_src pugs
    
    ;; test
    
    ;; #+end_src
    
    ;; Finally you can use `edebug' to instrumentalize
    ;; `org-babel-expand-body:pugs' and continue to evaluate the code block. You
    ;; try to add header keywords and change the body of the code block and
    ;; reevaluate the code block to observe how things get handled.
    
    ;;
    ;; If you have questions as to any of the portions of the file defined
    ;; below please look to existing language support for guidance.
    ;;
    ;; If you are planning on adding a language to org-babel we would ask
    ;; that if possible you fill out the FSF copyright assignment form
    ;; available at https://orgmode.org/request-assign-future.txt as this
    ;; will make it possible to include your language support in the core
    ;; of Org-mode, otherwise unassigned language support files can still
    ;; be included in the contrib/ directory of the Org-mode repository.
    
    
    ;;; Requirements:
    
    ;; Use this section to list the requirements of this language.  Most
    ;; languages will require that at least the language be installed on
    ;; the user's system, and the Emacs major mode relevant to the
    ;; language be installed as well.
    
    ;;; Code:
    (require 'ob)
    (require 'ob-ref)
    (require 'ob-comint)
    (require 'ob-eval)
    ;; possibly require modes required for your language
    
    ;; optionally define a file extension for this language
    (add-to-list 'org-babel-tangle-lang-exts '("pugs" . "pgs"))
    
    ;; optionally declare default header arguments for this language
    (defvar org-babel-default-header-args:pugs '())
    
    ;; This function expands the body of a source code block by doing things like
    ;; prepending argument definitions to the body, it should be called by the
    ;; `org-babel-execute:pugs' function below. Variables get concatenated in
    ;; the `mapconcat' form, therefore to change the formatting you can edit the
    ;; `format' form.
    (defun org-babel-expand-body:pugs (body params &optional processed-params)
      "Expand BODY according to PARAMS, return the expanded body."
      (require 'inf-pugs nil t)
      (let ((vars (org-babel--get-vars (or processed-params (org-babel-process-params params)))))
        (concat
         (mapconcat ;; define any variables
          (lambda (pair)
            (format "%s=%S"
                    (car pair) (org-babel-pugs-var-to-pugs (cdr pair))))
          vars "\n")
         "\n" body "\n")))
    
    ;; This is the main function which is called to evaluate a code
    ;; block.
    ;;
    ;; This function will evaluate the body of the source code and
    ;; return the results as emacs-lisp depending on the value of the
    ;; :results header argument
    ;; - output means that the output to STDOUT will be captured and
    ;;   returned
    ;; - value means that the value of the last statement in the
    ;;   source code block will be returned
    ;;
    ;; The most common first step in this function is the expansion of the
    ;; PARAMS argument using `org-babel-process-params'.
    ;;
    ;; Please feel free to not implement options which aren't appropriate
    ;; for your language (e.g. not all languages support interactive
    ;; "session" evaluation).  Also you are free to define any new header
    ;; arguments which you feel may be useful -- all header arguments
    ;; specified by the user will be available in the PARAMS variable.
    
    ;; SDP: This is a very simple version.
    ;; SDP: I kept the original example just after if needed in future.
    (defun org-babel-execute:pugs (body params)
      "Execute a block of pugs code with org-babel."
      (let ((in-file (org-babel-temp-file "n" ".pgs"))
            (verbosity (or (cdr (assq :verbosity params)) 0)))
        (with-temp-file in-file
          (insert body))
        (org-babel-eval
    		(format "${PUGS} --no-preamble --no-color %s"
    			(org-babel-process-file-name in-file))
    		"")))
    
    ;; SDP: original `org-babel-execute:pugs' example.
    ;; (defun org-babel-execute:pugs (body params)
    ;;   "Execute a block of Pugs code with org-babel.
    ;; This function is called by `org-babel-execute-src-block'"
    ;;   (message "executing Pugs source code block")
    ;;   (let* ((processed-params (org-babel-process-params params))
    ;;          ;; set the session if the value of the session keyword is not the
    ;;          ;; string `none'
    ;;          (session (unless (string= value "none")
    ;;                    (org-babel-pugs-initiate-session
    ;;                     (cdr (assq :session processed-params)))))
    ;;          ;; variables assigned for use in the block
    ;;          (vars (org-babel--get-vars processed-params))
    ;;          (result-params (assq :result-params processed-params))
    ;;          ;; either OUTPUT or VALUE which should behave as described above
    ;;          (result-type (assq :result-type processed-params))
    ;;          ;; expand the body with `org-babel-expand-body:pugs'
    ;;          (full-body (org-babel-expand-body:pugs
    ;;                      body params processed-params)))
    ;;     ;; actually execute the source-code block either in a session or
    ;;     ;; possibly by dropping it to a temporary file and evaluating the
    ;;     ;; file.
    ;;     ;;
    ;;     ;; for session based evaluation the functions defined in
    ;;     ;; `org-babel-comint' will probably be helpful.
    ;;     ;;
    ;;     ;; for external evaluation the functions defined in
    ;;     ;; `org-babel-eval' will probably be helpful.
    ;;     ;;
    ;;     ;; when forming a shell command, or a fragment of code in some
    ;;     ;; other language, please preprocess any file names involved with
    ;;     ;; the function `org-babel-process-file-name'. (See the way that
    ;;     ;; function is used in the language files)
    ;;     ))
    
    ;; This function should be used to assign any variables in params in
    ;; the context of the session environment.
    (defun org-babel-prep-session:pugs (session params)
      "Prepare SESSION according to the header arguments specified in PARAMS."
      )
    
    (defun org-babel-pugs-var-to-pugs (var)
      "Convert an elisp var into a string of pugs source code
    specifying a var of the same value."
      (format "%S" var))
    
    (defun org-babel-pugs-table-or-string (results)
      "If the results look like a table, then convert them into an
    Emacs-lisp table, otherwise return the results as a string."
      )
    
    (defun org-babel-pugs-initiate-session (&optional session)
      "If there is not a current inferior-process-buffer in SESSION then create.
    Return the initialized session."
      (unless (string= session "none")
        ))
    
    (provide 'ob-pugs)
    ;;; ob-pugs.el ends here