source: trunk/magnolia-eclipse/src/org/magnolialang/core.clj@ 806

(ns org.magnolialang.core
  (:import
   (org.magnolialang.testutil RascalEval TestUtil)
   (org.magnolialang.magnolia MagnoliaFacts)))

(defn hello-str []
  (str "This is " org.magnolialang.magnolia.Magnolia/MAGNOLIA "."))

(defn say-hello []
  (println (hello-str))) 

(def Type_ModuleResource
  org.magnolialang.resources.IResourceManager/Type_ModuleResource)

(def Type_DefInfo MagnoliaFacts/Type_DefInfo)

;; (.getId (magnolia-language)) => "Magnolia"
;; (.getExtensions (magnolia-language)) => [".mg"]
;; (.getModuleName (.getParser (magnolia-language))) => "org::magnolialang::syntax::Magnolia"
(defn magnolia-language []
  (org.magnolialang.magnolia.Magnolia.))

(defn set-infra []
  (org.magnolialang.infra.ConsoleInfra/setInfra))

(def compiler-op
  (doto (new java.util.HashMap)
    (.put "MAGNOLIA_MODULE_PATH"
          (java.util.ArrayList.
           (map
            #(-> % (java.io.File.) (.getAbsolutePath))
            (let [ev (System/getenv "MAGNOLIA_MODULE_PATH")]
              (if ev (seq (.split #":" ev)) [])))))
    (.put "a" "A")
    (.put "b" "B")))

(defn init-compiler []
  (TestUtil/setInstance compiler-op)
  (let [state (TestUtil/getInstance)
        lang (magnolia-language)]
    (.addFile state
              "org.magnolialang.magnolia.templates.MagicMain"
              (java.io.File. "src/org/magnolialang/magnolia/templates/MagicMain.cxx"))
    (org.magnolialang.resources.LanguageRegistry/registerLanguage lang)
    (let [parser (.getParser lang)]
      (.initialize parser))))

(defn get-infra []
  (org.magnolialang.infra.Infra/get))

(defn get-parser [s]
  (.getParser (get-infra) s))

(defn get-magnolia-parser []
  (get-parser (.getModuleName (.getParser (magnolia-language)))))

(defn new-file-fact [l s]
  (org.magnolialang.testutil.UnmanagedFileFact. l s))

(defn new-mg-file-fact [s]
  (new-file-fact (magnolia-language) (java.io.File. s)))

;; for testing only, fixed module
(defn add-mg-module-fact []
  (let [state (TestUtil/getInstance)
        lang (magnolia-language)]
    (.addModuleResource state lang "basic.Basic" (java.io.File. "magnolia-tests/src/basic/Basic.mg"))))

;; (find-mg-module-fact "basic.Basic")
(defn find-mg-module-fact [s]
  (.findModuleFact (TestUtil/getInstance) (magnolia-language) s))

(defn get-mg-module-fact [s]
  (.getModuleFact (TestUtil/getInstance) (magnolia-language) s))

(defn get-name-ast [s]
  (.getNameAST (magnolia-language) s))

(defn get-parse-tree [s]
  (let [state (TestUtil/getInstance)
        lang (magnolia-language)
        modNameAst (.getNameAST lang s)]
    (.getParseTree state modNameAst)))

(defn get-imploded-tree [s]
  (let [state (TestUtil/getInstance)
        lang (magnolia-language)
        modNameAst (.getNameAST lang s)]
    (.getImplodedTree state modNameAst)))

(defn rstring [s]
  (.string org.magnolialang.terms.TermFactory/vf s))

(defn get-option-string-fact [s]
  (let [state (TestUtil/getInstance)]
    (.getOptionStringFact state (rstring s))))

(defn get-ric []
  (let [state (TestUtil/getInstance)
        compiler (.getCompiler state)
        evaluator (.getEvaluator compiler)
        ri (RascalEval. evaluator)]
    ri))

(defn rtostring [r]
  (RascalEval/resultToString r))

;; Evaluate in compiler Evaluator.
;; E.g. (reval "registerCompiler")
(defn reval [s]
  (.eval (get-ric) s))

(defn reval-str [s]
  (rtostring (reval s)))

;; E.g. (reval-more "import util::tasks::Manager; getFact; 5;")
(defn reval-more [s]
  (.evalMore (get-ric) s))

;; E.g. (rimport "util::tasks::Manager")
(defn rimport [s]
  (.doImport (get-ric) s))

(defn rcall
  ;; Clojure does not (yet) appear to support optional positional
  ;; arguments with default values, so we do it like this
  ([s as] (.call (get-ric) s as))
  ([s] (rcall s [])))

(defn rapply [s & as]
  (rcall s as))

(defn get-fact [type name]
  (.getFact (TestUtil/getInstance)
            type name))

(defn get-def-info [s]
  (get-fact Type_DefInfo
            (get-name-ast s)))

(defn get-flattened [s]
  (get-fact MagnoliaFacts/Type_Flattened (get-name-ast s)))

(defn get-contents [s]
  (get-fact MagnoliaFacts/Type_Contents (get-name-ast s)))

(defn get-type-checked [s]
  (get-fact MagnoliaFacts/Type_TypeChecked (get-name-ast s)))

;; E.g. (doseq [x (get-contents-seq "basic.Basic")]
;;        (prn (ctor-get-val (get-simplified x))))
(defn get-simplified [ast]
  (get-fact MagnoliaFacts/Type_Simplified ast))

(defn yield-term
  ([v a?] (org.magnolialang.terms.TermAdapter/yieldTerm v a?))
  ([v] (yield-term v false)))

(defn ctor-get-field [v s]
  (.ctorGetField (TestUtil/getInstance) v s))

(defn ctor-get-val [v]
  (ctor-get-field v "val"))

;; E.g. (doseq [x (get-contents-seq "basic.Basic")] (prn x))
(defn get-contents-seq [s] ;; string -> seq
  (iterator-seq (.iterator (ctor-get-val (get-contents s)))))

;; E.g. (println (get-cxx-code "basic.Basic"))
(defn get-cxx-code [s]
  (.getCxxCode (TestUtil/getInstance) (magnolia-language) s))

(defn view-flattened-module [s]
  (println (.getValue
            (rapply "prettyMagnolia"
                    (ctor-get-val (get-type-checked s))))))

(defn get-ri []
  (RascalEval.))

(defn peval [s]
  (.eval (get-ri) s))

(defn peval-str [s]
  (RascalEval/resultToString (peval s)))

(defn pcall [s as]
  (.call (get-ri) s as))