{-# LANGUAGE TypeFamilies #-}
-- | The logic to render Java code is contained in this module
module Drasil.GOOL.LanguageRenderer.JavaRenderer (
  -- * Java Code Configuration -- defines syntax of all Java code
  JavaCode(..), jName, jVersion
) where

import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..))
import Drasil.Shared.InterfaceCommon (UnRepr(..), Label, Body, Block, SVariable,
  Value, SValue, BodySym(..), oneLiner, BlockSym(..), TypeSym(..), TypeElim(..),
  getTypeString, VariableSym(..), VisibilitySym(..), VariableElim(..),
  ValueSym(..), Argument(..), Literal(..), MathConstant(..), VariableValue(..),
  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
  Comparison(..), ValueExpression(..), funcApp, extFuncApp, IndexTranslator(..),
  Reference(..), Array(..), List(..), ListStatement(..), Set(..),
  InternalList(..), EmptyStatement(..), MultiStatement(..), ValueStatement(..),
  AssignStatement(..), (&=), DeclStatement(..), PrintConsole(..),
  ReadConsole(..), FileHandling(..), PrintFile(..), ReadFile(..),
  StringStatement(..), FunctionSym, FuncAppStatement(..), CommentStatement(..),
  BinderSym(..), BinderElim(..), ControlStatement(..), ScopeSym(..),
  ParameterSym(..), MethodSym(..))
import Drasil.GOOL.InterfaceGOOL (Class, StateVar, CSStateVar, OOProg,
  ProgramSym(..), FileSym(..), ModuleSym(..), ClassSym(..), OOTypeSym(..),
  OOVariableSym(..), SelfSym(..), StateVarSym(..), AttachmentSym(..), OOValueSym,
  OOVariableValue, OOValueExpression(..), objMethodCall, selfMethodCall, newObj,
  InternalValueExp(..), OOFunctionSym(..), ($.), GetSet(..), OODeclStatement(..),
  OOFuncAppStatement(..), ObserverPattern(..), StrategyPattern(..),
  OOMethodSym(..))
import Drasil.Shared.RendererClassesCommon (CommonRenderSym, ImportSym(..),
  RenderBody(..), BodyElim, RenderBlock(..), BlockElim, RenderType(..),
  UnaryOpSym(..), BinaryOpSym(..), OpElim(uOpPrec, bOpPrec), RenderVariable(..),
  InternalVarElim(variableBind), RenderValue(..), ValueElim(valuePrec, valueInt),
  InternalListFunc(..), RenderFunction(..), FunctionElim(functionType),
  InternalAssignStmt(..), InternalIOStmt(..), InternalControlStmt(..),
  RenderStatement(..), StatementElim(statementTerm), RenderVisibility(..),
  VisibilityElim, MethodTypeSym(..), RenderParam(..),
  ParamElim(parameterName, parameterType), RenderMethod(..), MethodElim,
  BlockCommentSym(..), BlockCommentElim, ScopeElim(..), InternalBinderElim(..))
import qualified Drasil.Shared.RendererClassesCommon as RC (body, block, uOp,
  bOp, variable, value, function, statement, visibility, parameter, method,
  blockComment')
import Drasil.GOOL.RendererClassesOO (OORenderSym, RenderFile(..),
  PermElim(binding), InternalGetSet(..), OOMethodTypeSym(..),
  OORenderMethod(..), StateVarElim, RenderClass(..), ClassElim, RenderMod(..),
  ModuleElim)
import qualified Drasil.GOOL.RendererClassesOO as RC (perm, stateVar, class',
  module')
import Drasil.Shared.LanguageRenderer (new, elseIfLabel, forLabel, tryLabel,
  catchLabel, throwLabel, throwsLabel, importLabel, blockCmtStart, blockCmtEnd,
  docCmtStart, bodyStart, bodyEnd, endStatement, commentStart, exceptionObj',
  new', args, printLabel, exceptionObj, mainFunc, new, nullLabel, listSep,
  access, containing, mathFunc, functionDox, variableList,
  parameterList, appendToBody, surroundBody, valueList)
import qualified Drasil.Shared.LanguageRenderer as R (sqrt, abs, log10,
  log, exp, sin, cos, tan, asin, acos, atan, floor, ceil, pow, package, class',
  multiStmt, body, printFile, classVarAccess, cast, castObj,
  classLevel, instanceLevel, break, continue, private, public, blockCmt, docCmt,
  addComments, commentedMod, commentedItem)
import Drasil.GOOL.Renderers (renderType, renderParam, renderListDec)
import Drasil.Shared.LanguageRenderer.Constructors (mkStmt, mkStateVal, mkVal,
  typeFromData, VSOp, unOpPrec, powerPrec, unExpr, unExpr', unExprNumDbl,
  typeUnExpr, binExpr, binExprNumDbl', typeBinExpr, typeFromData)
import qualified Drasil.Shared.LanguageRenderer.LanguagePolymorphic as G (
  multiBody, block, multiBlock, obj, csc, sec, cot, negateOp, equalOp,
  notEqualOp, greaterOp, greaterEqualOp, lessOp, lessEqualOp, plusOp, minusOp,
  multOp, divideOp, moduloOp, var, classVar, instanceVarAccess, arrayElem,
  litChar, litDouble, litInt, litString, valueOf, arg, argsList, objAccess,
  objMethodCall, funcAppMixedArgs, newObjMixedArgs, lambda, func, get, set,
  listAccess, getFunc, setFunc, stmt, loopStmt, emptyStmt, assign, subAssign,
  objDecNew, print, closeFile, returnStmt, valStmt, comment, throw, ifCond,
  tryCatch, construct, param, method, getMethod, setMethod, function, buildClass,
  implementingClass, commentedClass, modFromData, fileDoc, fileFromData,
  defaultOptSpace, local)
import Drasil.Shared.LanguageRenderer.LanguagePolymorphic (docFuncRepr)
import qualified Drasil.Shared.LanguageRenderer.CommonPseudoOO as CP
import qualified Drasil.Shared.LanguageRenderer.CLike as C (float, double, char,
  listType, void, notOp, andOp, orOp, self, litTrue, litFalse, litFloat,
  inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs, listSize, increment,
  increment1, decrement1, varDec, varDecDef, listDec, extObjDecNew, switch, for,
  while, multiAssignError, multiReturnError, multiTypeError, setType)
import qualified Drasil.Shared.LanguageRenderer.Macros as M (ifExists,
  runStrategy, listSlice, stringListVals, stringListLists, forRange,
  notifyObservers)
import qualified Drasil.GOOL.LanguageRenderer.CommonGOOL as CG (classMethodCall,
  listAppend, listAdd, innerType)
import Drasil.Shared.AST (Terminator(..), VisibilityTag(..), qualName,
  FileType(..), fileD, FuncData(..), fd, ModData(..), md, updateMod,
  MethodData(..), mthd, updateMthd, OpData(..), ParamData(..), pd, ProgData(..),
  progD, TypeData(..), ValData(..), vd, VarData(..), vard, ScopeData,
  BinderD(..), bindFormD, FileData)
import Drasil.Shared.CodeAnalysis (Exception(..), ExceptionType(..), exception,
  stdExc, HasException(..))
import Drasil.Shared.Helpers (emptyIfNull, toCode, toState, onCodeValue,
  onStateValue, on2CodeValues, on2StateValues, on3CodeValues, on3StateValues,
  onCodeList, onStateList, on2StateWrapped)
import Drasil.Shared.State (CS, MS, VS, lensGStoFS, lensMStoFS, lensMStoVS,
  lensVStoFS, lensVStoMS, modifyReturn, modifyReturnList, revFiles,
  addProgNameToPaths, addLangImport, addLangImportVS, addExceptionImports,
  getModuleName, setFileType, getClassName, setCurrMain, setOutputsDeclared,
  isOutputsDeclared, getExceptions, getMethodExcMap, addExceptions, useVarName,
  setVarScope)

import Prelude hiding (break,print,sin,cos,tan,floor,(<>))
import Control.Lens.Zoom (zoom)
import Control.Monad (join)
import Control.Monad.State (modify)
import Data.Composition ((.:))
import qualified Data.Map as Map (lookup)
import Data.List (nub, intercalate, sort)
import Text.PrettyPrint.HughesPJ (Doc, text, (<>), (<+>), ($$), parens, empty,
  equals, vcat, lbrace, rbrace, braces, colon, quotes)

import qualified Drasil.Shared.LanguageRenderer.Common as CS

jExt :: String
jExt :: String
jExt = String
"java"

newtype JavaCode a = JC {forall a. JavaCode a -> a
unJC :: a}

instance Functor JavaCode where
  fmap :: forall a b. (a -> b) -> JavaCode a -> JavaCode b
fmap a -> b
f (JC a
x) = b -> JavaCode b
forall a. a -> JavaCode a
JC (a -> b
f a
x)

instance Applicative JavaCode where
  pure :: forall a. a -> JavaCode a
pure = a -> JavaCode a
forall a. a -> JavaCode a
JC
  (JC a -> b
f) <*> :: forall a b. JavaCode (a -> b) -> JavaCode a -> JavaCode b
<*> (JC a
x) = b -> JavaCode b
forall a. a -> JavaCode a
JC (a -> b
f a
x)

instance Monad JavaCode where
  JC a
x >>= :: forall a b. JavaCode a -> (a -> JavaCode b) -> JavaCode b
>>= a -> JavaCode b
f = a -> JavaCode b
f a
x

instance OOProg JavaCode Doc (Doc, Terminator) MethodData StateVar Doc ProgData FileData ModData Body Block

instance ProgramSym JavaCode ProgData FileData where
  prog :: String
-> String
-> [FS (JavaCode FileData)]
-> GSProgram JavaCode ProgData
prog String
n String
st [FS (JavaCode FileData)]
fs = [State GOOLState (JavaCode FileData)]
-> (GOOLState -> GOOLState)
-> ([JavaCode FileData] -> JavaCode ProgData)
-> GSProgram JavaCode ProgData
forall s b a. [State s b] -> (s -> s) -> ([b] -> a) -> State s a
modifyReturnList ((FS (JavaCode FileData) -> State GOOLState (JavaCode FileData))
-> [FS (JavaCode FileData)]
-> [State GOOLState (JavaCode FileData)]
forall a b. (a -> b) -> [a] -> [b]
map (LensLike'
  (Zoomed (StateT FileState Identity) (JavaCode FileData))
  GOOLState
  FileState
-> FS (JavaCode FileData) -> State GOOLState (JavaCode FileData)
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) GOOLState FileState
-> StateT FileState Identity c -> StateT GOOLState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) (JavaCode FileData))
  GOOLState
  FileState
(FileState -> Focusing Identity (JavaCode FileData) FileState)
-> GOOLState -> Focusing Identity (JavaCode FileData) GOOLState
Lens' GOOLState FileState
lensGStoFS) [FS (JavaCode FileData)]
fs) (GOOLState -> GOOLState
revFiles (GOOLState -> GOOLState)
-> (GOOLState -> GOOLState) -> GOOLState -> GOOLState
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    String -> GOOLState -> GOOLState
addProgNameToPaths String
n) (([FileData] -> ProgData)
-> [JavaCode FileData] -> JavaCode ProgData
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList (String -> String -> [FileData] -> ProgData
progD String
n String
st ([FileData] -> ProgData)
-> ([FileData] -> [FileData]) -> [FileData] -> ProgData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FileData -> FileData) -> [FileData] -> [FileData]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Doc -> FileData -> FileData
R.package String
n
    Doc
endStatement)))

instance CommonRenderSym JavaCode Doc (Doc, Terminator) MethodData Body Block
instance OORenderSym JavaCode Doc (Doc, Terminator) MethodData StateVar Doc FileData ModData Body Block

instance UnRepr JavaCode contents where
  unRepr :: JavaCode contents -> contents
unRepr = JavaCode contents -> contents
forall a. JavaCode a -> a
unJC

instance FileSym JavaCode FileData ModData where
  fileDoc :: FS (JavaCode ModData) -> FS (JavaCode FileData)
fileDoc FS (JavaCode ModData)
m = do
    (FileState -> FileState) -> StateT FileState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (FileType -> FileState -> FileState
setFileType FileType
Combined)
    String
-> (JavaCode ModData -> JavaCode Doc)
-> JavaCode Doc
-> FS (JavaCode ModData)
-> FS (JavaCode FileData)
forall (r :: * -> *) block mod file.
(BlockElim r block, RenderMod r mod, RenderFile r file mod) =>
String
-> (r mod -> r block) -> r block -> FS (r mod) -> FS (r file)
G.fileDoc String
jExt JavaCode ModData -> JavaCode Doc
forall (r :: * -> *) file mod.
RenderFile r file mod =>
r mod -> r Doc
top JavaCode Doc
forall (r :: * -> *) file mod. RenderFile r file mod => r Doc
bottom FS (JavaCode ModData)
m

  docMod :: String
-> String
-> [String]
-> String
-> FS (JavaCode FileData)
-> FS (JavaCode FileData)
docMod = String
-> String
-> String
-> [String]
-> String
-> FS (JavaCode FileData)
-> FS (JavaCode FileData)
forall (r :: * -> *) file mod.
RenderFile r file mod =>
String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
CP.doxMod String
jExt

instance RenderFile JavaCode FileData ModData where
  top :: JavaCode ModData -> JavaCode Doc
top JavaCode ModData
_ = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty
  bottom :: JavaCode Doc
bottom = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty

  commentedMod :: FS (JavaCode FileData)
-> FS (JavaCode Doc) -> FS (JavaCode FileData)
commentedMod = (JavaCode FileData -> JavaCode Doc -> JavaCode FileData)
-> FS (JavaCode FileData)
-> FS (JavaCode Doc)
-> FS (JavaCode FileData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((FileData -> Doc -> FileData)
-> JavaCode FileData -> JavaCode Doc -> JavaCode FileData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues FileData -> Doc -> FileData
R.commentedMod)

  fileFromData :: String -> FS (JavaCode ModData) -> FS (JavaCode FileData)
fileFromData = (String -> JavaCode ModData -> JavaCode FileData)
-> String -> FS (JavaCode ModData) -> FS (JavaCode FileData)
forall {k} (r :: k -> *) (mod :: k) (file :: k).
ModuleElim r mod =>
(String -> r mod -> r file) -> String -> FS (r mod) -> FS (r file)
G.fileFromData ((ModData -> FileData) -> JavaCode ModData -> JavaCode FileData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((ModData -> FileData) -> JavaCode ModData -> JavaCode FileData)
-> (String -> ModData -> FileData)
-> String
-> JavaCode ModData
-> JavaCode FileData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ModData -> FileData
fileD)

instance ImportSym JavaCode where
  langImport :: String -> JavaCode Doc
langImport = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> (String -> Doc) -> String -> JavaCode Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
jImport
  modImport :: String -> JavaCode Doc
modImport = String -> JavaCode Doc
forall (r :: * -> *). ImportSym r => String -> r Doc
langImport

instance AttachmentSym JavaCode Doc where
  classLevel :: JavaCode Doc
classLevel = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.classLevel
  instanceLevel :: JavaCode Doc
instanceLevel = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.instanceLevel

instance PermElim JavaCode Doc where
  perm :: JavaCode Doc -> Doc
perm = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC
  binding :: JavaCode Doc -> AttachmentTag
binding = String -> JavaCode Doc -> AttachmentTag
forall a. HasCallStack => String -> a
error (String -> JavaCode Doc -> AttachmentTag)
-> String -> JavaCode Doc -> AttachmentTag
forall a b. (a -> b) -> a -> b
$ String -> String
CP.bindingError String
jName

instance BodySym JavaCode Body Block where
  body :: [MS (JavaCode Doc)] -> MS (JavaCode Doc)
body = ([JavaCode Doc] -> JavaCode Doc)
-> [MS (JavaCode Doc)] -> MS (JavaCode Doc)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([Doc] -> Doc) -> [JavaCode Doc] -> JavaCode Doc
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [Doc] -> Doc
R.body)

  addComments :: String -> MS (JavaCode Doc) -> MS (JavaCode Doc)
addComments String
s = (JavaCode Doc -> JavaCode Doc)
-> MS (JavaCode Doc) -> MS (JavaCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Doc -> Doc) -> JavaCode Doc -> JavaCode Doc
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (String -> Doc -> Doc -> Doc
R.addComments String
s Doc
commentStart))

instance RenderBody JavaCode Body where
  multiBody :: [MS (JavaCode Doc)] -> MS (JavaCode Doc)
multiBody = [MS (JavaCode Doc)] -> MS (JavaCode Doc)
forall (r :: * -> *) bod.
(BodyElim r bod, Monad r) =>
[MS (r bod)] -> MS (r Doc)
G.multiBody

instance BodyElim JavaCode Body where
  body :: JavaCode Doc -> Doc
body = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance BlockSym JavaCode Block (Doc, Terminator) where
  block :: [MS (JavaCode (Doc, Terminator))] -> MS (JavaCode Doc)
block = [MS (JavaCode (Doc, Terminator))] -> MS (JavaCode Doc)
forall (r :: * -> *) stmt.
(Monad r, RenderStatement r stmt, StatementElim r stmt) =>
[MS (r stmt)] -> MS (r Doc)
G.block

instance RenderBlock JavaCode Block where
  multiBlock :: [MS (JavaCode Doc)] -> MS (JavaCode Doc)
multiBlock = [MS (JavaCode Doc)] -> MS (JavaCode Doc)
forall (r :: * -> *) block.
(BlockElim r block, Monad r) =>
[MS (r block)] -> MS (r Doc)
G.multiBlock

instance BlockElim JavaCode Block where
  block :: JavaCode Doc -> Doc
block = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance TypeSym JavaCode where
  bool :: VS (JavaCode TypeData)
bool = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jBoolType
  int :: VS (JavaCode TypeData)
int = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.int
  float :: VS (JavaCode TypeData)
float = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.float
  double :: VS (JavaCode TypeData)
double = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.double
  char :: VS (JavaCode TypeData)
char = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.char
  string :: VS (JavaCode TypeData)
string = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.string'
  infile :: VS (JavaCode TypeData)
infile = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jInfileType
  outfile :: VS (JavaCode TypeData)
outfile = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jOutfileType
  referenceType :: VS (JavaCode TypeData) -> VS (JavaCode TypeData)
referenceType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall a. a -> a
id -- Ignore reference types in "high-level" langauges for now; later on think about using boxed/unboxed types
  listType :: VS (JavaCode TypeData) -> VS (JavaCode TypeData)
listType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
(TypeElim r, UnRepr r TypeData, Monad r) =>
VS (r TypeData) -> VS (r TypeData)
jListType
  setType :: VS (JavaCode TypeData) -> VS (JavaCode TypeData)
setType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
(TypeElim r, UnRepr r TypeData, Monad r) =>
VS (r TypeData) -> VS (r TypeData)
jSetType
  arrayType :: VS (JavaCode TypeData) -> VS (JavaCode TypeData)
arrayType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
(TypeElim r, Monad r, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
CP.arrayType
  innerType :: VS (JavaCode TypeData) -> VS (JavaCode TypeData)
innerType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
(TypeElim r, OOTypeSym r) =>
VS (r TypeData) -> VS (r TypeData)
CG.innerType
  funcType :: [VS (JavaCode TypeData)]
-> VS (JavaCode TypeData) -> VS (JavaCode TypeData)
funcType = [VS (JavaCode TypeData)]
-> VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r) =>
[VS (r TypeData)] -> VS (r TypeData) -> VS (r TypeData)
CS.funcType -- TODO [Brandon Bosman, 05/11/2026]: fix this to work with lambda types
  void :: VS (JavaCode TypeData)
void = VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.void

instance TypeElim JavaCode where
  getCodeType :: JavaCode TypeData -> CodeType
getCodeType = TypeData -> CodeType
cType (TypeData -> CodeType)
-> (JavaCode TypeData -> TypeData) -> JavaCode TypeData -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> TypeData
forall a. JavaCode a -> a
unJC

instance OOTypeSym JavaCode where
  obj :: String -> VS (JavaCode TypeData)
obj = String -> VS (JavaCode TypeData)
forall (r :: * -> *). Monad r => String -> VS (r TypeData)
G.obj

instance RenderType JavaCode where
  multiType :: [VS (JavaCode TypeData)] -> VS (JavaCode TypeData)
multiType [VS (JavaCode TypeData)]
_ = String -> VS (JavaCode TypeData)
forall a. HasCallStack => String -> a
error (String -> VS (JavaCode TypeData))
-> String -> VS (JavaCode TypeData)
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiTypeError String
jName

instance UnaryOpSym JavaCode where
  notOp :: VSUnOp JavaCode
notOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
C.notOp
  negateOp :: VSUnOp JavaCode
negateOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.negateOp
  sqrtOp :: VSUnOp JavaCode
sqrtOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.sqrt
  absOp :: VSUnOp JavaCode
absOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.abs
  logOp :: VSUnOp JavaCode
logOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.log10
  lnOp :: VSUnOp JavaCode
lnOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.log
  expOp :: VSUnOp JavaCode
expOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.exp
  sinOp :: VSUnOp JavaCode
sinOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.sin
  cosOp :: VSUnOp JavaCode
cosOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.cos
  tanOp :: VSUnOp JavaCode
tanOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.tan
  asinOp :: VSUnOp JavaCode
asinOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.asin
  acosOp :: VSUnOp JavaCode
acosOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.acos
  atanOp :: VSUnOp JavaCode
atanOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.atan
  floorOp :: VSUnOp JavaCode
floorOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.floor
  ceilOp :: VSUnOp JavaCode
ceilOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.ceil

instance BinaryOpSym JavaCode where
  equalOp :: VSUnOp JavaCode
equalOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.equalOp
  notEqualOp :: VSUnOp JavaCode
notEqualOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.notEqualOp
  greaterOp :: VSUnOp JavaCode
greaterOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterOp
  greaterEqualOp :: VSUnOp JavaCode
greaterEqualOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterEqualOp
  lessOp :: VSUnOp JavaCode
lessOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.lessOp
  lessEqualOp :: VSUnOp JavaCode
lessEqualOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.lessEqualOp
  plusOp :: VSUnOp JavaCode
plusOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.plusOp
  minusOp :: VSUnOp JavaCode
minusOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.minusOp
  multOp :: VSUnOp JavaCode
multOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.multOp
  divideOp :: VSUnOp JavaCode
divideOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.divideOp
  powerOp :: VSUnOp JavaCode
powerOp = String -> VSUnOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
powerPrec (String -> VSUnOp JavaCode) -> String -> VSUnOp JavaCode
forall a b. (a -> b) -> a -> b
$ String -> String
mathFunc String
R.pow
  moduloOp :: VSUnOp JavaCode
moduloOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
G.moduloOp
  andOp :: VSUnOp JavaCode
andOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
C.andOp
  orOp :: VSUnOp JavaCode
orOp = VSUnOp JavaCode
forall (r :: * -> *). Monad r => VSOp r
C.orOp

instance OpElim JavaCode where
  uOp :: JavaCode OpData -> Doc
uOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (JavaCode OpData -> OpData) -> JavaCode OpData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode OpData -> OpData
forall a. JavaCode a -> a
unJC
  bOp :: JavaCode OpData -> Doc
bOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (JavaCode OpData -> OpData) -> JavaCode OpData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode OpData -> OpData
forall a. JavaCode a -> a
unJC
  uOpPrec :: JavaCode OpData -> Int
uOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (JavaCode OpData -> OpData) -> JavaCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode OpData -> OpData
forall a. JavaCode a -> a
unJC
  bOpPrec :: JavaCode OpData -> Int
bOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (JavaCode OpData -> OpData) -> JavaCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode OpData -> OpData
forall a. JavaCode a -> a
unJC

instance ScopeSym JavaCode where
  global :: JavaCode ScopeData
global = JavaCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
CP.global
  mainFn :: JavaCode ScopeData
mainFn = JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local
  local :: JavaCode ScopeData
local = JavaCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
G.local

instance ScopeElim JavaCode where
  scopeData :: JavaCode ScopeData -> ScopeData
scopeData = JavaCode ScopeData -> ScopeData
forall a. JavaCode a -> a
unJC

instance VariableSym JavaCode where
  var :: String -> VS (JavaCode TypeData) -> SVariable JavaCode
var         = String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> SVariable r
G.var
  constant :: String -> VS (JavaCode TypeData) -> SVariable JavaCode
constant    = String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
var
  extVar :: String -> String -> VS (JavaCode TypeData) -> SVariable JavaCode
extVar      = String -> String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
RenderVariable r =>
String -> String -> VS (r TypeData) -> SVariable r
CS.extVar

instance OOVariableSym JavaCode where
  classVar :: String -> VS (JavaCode TypeData) -> SVariable JavaCode
classVar = String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> SVariable r
G.classVar
  classConst :: String -> VS (JavaCode TypeData) -> SVariable JavaCode
classConst = String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
OOVariableSym r =>
String -> VS (r TypeData) -> SVariable r
classVar
  classVarAccess :: VS (JavaCode TypeData) -> SVariable JavaCode -> SVariable JavaCode
classVarAccess = (Doc -> Doc -> Doc)
-> VS (JavaCode TypeData)
-> SVariable JavaCode
-> SVariable JavaCode
forall (r :: * -> *).
(InternalVarElim r, RenderVariable r, UnRepr r TypeData,
 VariableElim r) =>
(Doc -> Doc -> Doc)
-> VS (r TypeData) -> SVariable r -> SVariable r
CP.classVarAccess Doc -> Doc -> Doc
R.classVarAccess
  extClassVarAccess :: VS (JavaCode TypeData) -> SVariable JavaCode -> SVariable JavaCode
extClassVarAccess = VS (JavaCode TypeData) -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
OOVariableSym r =>
VS (r TypeData) -> SVariable r -> SVariable r
classVarAccess
  instanceVarAccess :: SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
instanceVarAccess = SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
(InternalVarElim r, RenderVariable r, ValueElim r,
 VariableElim r) =>
SValue r -> SVariable r -> SVariable r
G.instanceVarAccess

instance SelfSym JavaCode where
  self :: SVariable JavaCode
self = SVariable JavaCode
forall (r :: * -> *).
(OOTypeSym r, RenderVariable r) =>
SVariable r
C.self

instance VariableElim JavaCode where
  variableName :: JavaCode Variable -> String
variableName = Variable -> String
varName (Variable -> String)
-> (JavaCode Variable -> Variable) -> JavaCode Variable -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Variable -> Variable
forall a. JavaCode a -> a
unJC
  variableType :: JavaCode Variable -> JavaCode TypeData
variableType = (Variable -> TypeData) -> JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Variable -> TypeData
varType

instance InternalVarElim JavaCode where
  variableBind :: JavaCode Variable -> AttachmentTag
variableBind = Variable -> AttachmentTag
varBind (Variable -> AttachmentTag)
-> (JavaCode Variable -> Variable)
-> JavaCode Variable
-> AttachmentTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Variable -> Variable
forall a. JavaCode a -> a
unJC
  variable :: JavaCode Variable -> Doc
variable = Variable -> Doc
varDoc (Variable -> Doc)
-> (JavaCode Variable -> Variable) -> JavaCode Variable -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Variable -> Variable
forall a. JavaCode a -> a
unJC

instance RenderVariable JavaCode where
  varFromData :: AttachmentTag
-> String -> VS (JavaCode TypeData) -> Doc -> SVariable JavaCode
varFromData AttachmentTag
b String
n VS (JavaCode TypeData)
t' Doc
d =  do
    t <- VS (JavaCode TypeData)
t'
    toState $ on2CodeValues (vard b n) t (toCode d)

instance ValueSym JavaCode where
  valueType :: JavaCode Value -> JavaCode TypeData
valueType = (Value -> TypeData) -> JavaCode Value -> JavaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Value -> TypeData
valType

instance OOValueSym JavaCode

instance Argument JavaCode where
  pointerArg :: SValue JavaCode -> SValue JavaCode
pointerArg = SValue JavaCode -> SValue JavaCode
forall a. a -> a
id

instance Literal JavaCode where
  litTrue :: SValue JavaCode
litTrue = SValue JavaCode
forall (r :: * -> *). (RenderValue r, TypeSym r) => SValue r
C.litTrue
  litFalse :: SValue JavaCode
litFalse = SValue JavaCode
forall (r :: * -> *). (RenderValue r, TypeSym r) => SValue r
C.litFalse
  litChar :: Char -> SValue JavaCode
litChar = (Doc -> Doc) -> Char -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
(Doc -> Doc) -> Char -> SValue r
G.litChar Doc -> Doc
quotes
  litDouble :: Double -> SValue JavaCode
litDouble = Double -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
Double -> SValue r
G.litDouble
  litFloat :: Float -> SValue JavaCode
litFloat = Float -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
Float -> SValue r
C.litFloat
  litInt :: Integer -> SValue JavaCode
litInt = Integer -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
Integer -> SValue r
G.litInt
  litString :: String -> SValue JavaCode
litString = String -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
String -> SValue r
G.litString
  litArray :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
litArray = VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jLitArray
  litSet :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
litSet = (Doc -> Doc)
-> (Doc -> Doc)
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
(Doc -> Doc)
-> (Doc -> Doc) -> VS (r TypeData) -> [SValue r] -> SValue r
CP.litSet (String -> Doc
text String
jSetOf Doc -> Doc -> Doc
<>) Doc -> Doc
parens

  litList :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
litList VS (JavaCode TypeData)
t [SValue JavaCode]
es = do
    LensLike'
  (Zoomed (StateT MethodState Identity) ()) ValueState MethodState
-> StateT MethodState Identity () -> StateT ValueState Identity ()
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) ValueState MethodState
-> StateT MethodState Identity c -> StateT ValueState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT MethodState Identity) ()) ValueState MethodState
Lens' ValueState MethodState
lensVStoMS (StateT MethodState Identity () -> StateT ValueState Identity ())
-> StateT MethodState Identity () -> StateT ValueState Identity ()
forall a b. (a -> b) -> a -> b
$ (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (if [SValue JavaCode] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [SValue JavaCode]
es then MethodState -> MethodState
forall a. a -> a
id else String -> MethodState -> MethodState
addLangImport (String -> MethodState -> MethodState)
-> String -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport
      String
jArrays)
    VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj (VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
listType VS (JavaCode TypeData)
t) [VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc VS (JavaCode TypeData)
t [SValue JavaCode]
es | Bool -> Bool
not ([SValue JavaCode] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [SValue JavaCode]
es)]

instance MathConstant JavaCode where
  pi :: SValue JavaCode
pi = SValue JavaCode
forall (r :: * -> *). (RenderValue r, TypeSym r) => SValue r
CP.pi

instance VariableValue JavaCode where
  valueOf :: SVariable JavaCode -> SValue JavaCode
valueOf = SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *).
(InternalVarElim r, RenderValue r, VariableElim r) =>
SVariable r -> SValue r
G.valueOf

instance OOVariableValue JavaCode

instance CommandLineArgs JavaCode where
  arg :: Integer -> SValue JavaCode
arg Integer
n = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
SValue r -> SValue r -> SValue r
G.arg (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n) SValue JavaCode
forall (r :: * -> *). CommandLineArgs r => SValue r
argsList
  argsList :: SValue JavaCode
argsList = String -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
String -> SValue r
G.argsList String
args
  argExists :: Integer -> SValue JavaCode
argExists Integer
i = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). List r => SValue r -> SValue r
listSize SValue JavaCode
forall (r :: * -> *). CommandLineArgs r => SValue r
argsList SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
Comparison r =>
SValue r -> SValue r -> SValue r
?> Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i)

instance NumericExpression JavaCode where
  #~ :: SValue JavaCode -> SValue JavaCode
(#~) = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr' VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
negateOp
  #/^ :: SValue JavaCode -> SValue JavaCode
(#/^) = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sqrtOp
  #| :: SValue JavaCode -> SValue JavaCode
(#|) = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#+) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  #- :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#-) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp
  #* :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#*) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  #/ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#/) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp
  #% :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#%) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#^) = VSUnOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExprNumDbl' VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp

  log :: SValue JavaCode -> SValue JavaCode
log = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: SValue JavaCode -> SValue JavaCode
ln = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: SValue JavaCode -> SValue JavaCode
exp = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: SValue JavaCode -> SValue JavaCode
sin = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: SValue JavaCode -> SValue JavaCode
cos = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: SValue JavaCode -> SValue JavaCode
tan = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: SValue JavaCode -> SValue JavaCode
csc = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.csc
  sec :: SValue JavaCode -> SValue JavaCode
sec = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.sec
  cot :: SValue JavaCode -> SValue JavaCode
cot = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.cot
  arcsin :: SValue JavaCode -> SValue JavaCode
arcsin = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: SValue JavaCode -> SValue JavaCode
arccos = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: SValue JavaCode -> SValue JavaCode
arctan = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: SValue JavaCode -> SValue JavaCode
floor = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
floorOp
  ceil :: SValue JavaCode -> SValue JavaCode
ceil = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
ceilOp

instance BooleanExpression JavaCode where
  ?! :: SValue JavaCode -> SValue JavaCode
(?!) = VSUnOp JavaCode
-> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSUnOp r -> VS (r TypeData) -> SValue r -> SValue r
typeUnExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
notOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?&& :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?&&) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?|| :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?||) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
orOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool

instance Comparison JavaCode where
  ?< :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?<) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?<= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?<=) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?> :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?>= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>=) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterEqualOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool
  ?== :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?==) = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
jEquality
  ?!= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?!=) = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
notEqualOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool

instance ValueExpression JavaCode where
  inlineIf :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
inlineIf = SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(RenderValue r, ValueElim r, ValueSym r) =>
SValue r -> SValue r -> SValue r -> SValue r
C.inlineIf

  -- Exceptions from function/method calls should already be in the exception
  -- map from the CodeInfo pass, but it's possible that one of the higher-level
  -- functions implicitly calls these functions in the Java renderer, so we
  -- also check here to add the exceptions from the called function to the map
  funcAppMixedArgs :: MixedCall JavaCode
funcAppMixedArgs String
n VS (JavaCode TypeData)
t [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n
    MixedCall JavaCode
forall (r :: * -> *). RenderValue r => MixedCall r
G.funcAppMixedArgs String
n VS (JavaCode TypeData)
t [SValue JavaCode]
vs NamedArgs JavaCode
ns
  extFuncAppMixedArgs :: String -> MixedCall JavaCode
extFuncAppMixedArgs String
l String
n VS (JavaCode TypeData)
t [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    modify (maybe id addExceptions (Map.lookup (qualName l n) mem))
    CS.extFuncAppMixedArgs l n t vs ns
  libFuncAppMixedArgs :: String -> MixedCall JavaCode
libFuncAppMixedArgs = String -> MixedCall JavaCode
forall (r :: * -> *). ValueExpression r => String -> MixedCall r
C.libFuncAppMixedArgs

  lambda :: [VSBinder JavaCode] -> SValue JavaCode -> SValue JavaCode
lambda = ([JavaCode BinderD] -> JavaCode Value -> Doc)
-> [VSBinder JavaCode] -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(BinderElim r, RenderValue r, ValueSym r) =>
([r BinderD] -> r Value -> Doc)
-> [VSBinder r] -> SValue r -> SValue r
G.lambda [JavaCode BinderD] -> JavaCode Value -> Doc
forall (r :: * -> *). [r BinderD] -> r Value -> Doc
jLambda

  notNull :: SValue JavaCode -> SValue JavaCode
notNull = String -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(Comparison r, VariableValue r) =>
String -> SValue r -> SValue r
CP.notNull String
nullLabel

instance OOValueExpression JavaCode where
  newObjMixedArgs :: MixedCtorCall JavaCode
newObjMixedArgs VS (JavaCode TypeData)
ot [SValue JavaCode]
vs NamedArgs JavaCode
ns = VS (JavaCode TypeData)
-> (VS (JavaCode TypeData) -> SValue JavaCode) -> SValue JavaCode
forall (r :: * -> *).
UnRepr r TypeData =>
VS (r TypeData) -> (VS (r TypeData) -> SValue r) -> SValue r
addConstructorCallExcsCurrMod VS (JavaCode TypeData)
ot (\VS (JavaCode TypeData)
t ->
    MixedCall JavaCode
forall (r :: * -> *).
(RenderValue r, UnRepr r TypeData) =>
String -> MixedCtorCall r
G.newObjMixedArgs (String
new String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ") VS (JavaCode TypeData)
t [SValue JavaCode]
vs NamedArgs JavaCode
ns)
  extNewObjMixedArgs :: MixedCall JavaCode
extNewObjMixedArgs String
l VS (JavaCode TypeData)
ot [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    t <- VS (JavaCode TypeData)
ot
    mem <- getMethodExcMap
    let tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString JavaCode TypeData
t
    modify (maybe id addExceptions (Map.lookup (qualName l tp) mem))
    newObjMixedArgs (toState t) vs ns
  libNewObjMixedArgs :: MixedCall JavaCode
libNewObjMixedArgs = MixedCall JavaCode
forall (r :: * -> *).
OOValueExpression r =>
String -> MixedCtorCall r
C.libNewObjMixedArgs

instance RenderValue JavaCode where
  inputFunc :: SValue JavaCode
inputFunc = (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
jScanner) StateT ValueState Identity () -> SValue JavaCode -> SValue JavaCode
forall a b.
StateT ValueState Identity a
-> StateT ValueState Identity b -> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VS (JavaCode TypeData) -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal
    (String -> VS (JavaCode TypeData)
forall (r :: * -> *). OOTypeSym r => String -> VS (r TypeData)
obj String
jScanner) (Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ Doc
new' Doc -> Doc -> Doc
<+> Doc
jScanner' Doc -> Doc -> Doc
<> Doc -> Doc
parens (String -> Doc
jSystem String
jStdIn))
  printFunc :: SValue JavaCode
printFunc = VS (JavaCode TypeData) -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void (String -> Doc
jSystem (String
jStdOut String -> String -> String
`access` String
printLabel))
  printLnFunc :: SValue JavaCode
printLnFunc = VS (JavaCode TypeData) -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void (String -> Doc
jSystem (String
jStdOut String -> String -> String
`access` String
jPrintLn))
  printFileFunc :: SValue JavaCode -> SValue JavaCode
printFileFunc = (JavaCode TypeData -> JavaCode Value -> SValue JavaCode)
-> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\JavaCode TypeData
v -> JavaCode TypeData -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
r TypeData -> Doc -> SValue r
mkVal JavaCode TypeData
v (Doc -> SValue JavaCode)
-> (JavaCode Value -> Doc) -> JavaCode Value -> SValue JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
printLabel (Doc -> Doc) -> (JavaCode Value -> Doc) -> JavaCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    JavaCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value) VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void
  printFileLnFunc :: SValue JavaCode -> SValue JavaCode
printFileLnFunc = (JavaCode TypeData -> JavaCode Value -> SValue JavaCode)
-> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\JavaCode TypeData
v -> JavaCode TypeData -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
r TypeData -> Doc -> SValue r
mkVal JavaCode TypeData
v (Doc -> SValue JavaCode)
-> (JavaCode Value -> Doc) -> JavaCode Value -> SValue JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
jPrintLn (Doc -> Doc) -> (JavaCode Value -> Doc) -> JavaCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    JavaCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value) VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void

  cast :: VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
cast = VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
jCast

  call :: Maybe String -> Maybe Doc -> MixedCall JavaCode
call = String -> Maybe String -> Maybe Doc -> MixedCall JavaCode
forall (r :: * -> *).
(InternalVarElim r, RenderValue r, ValueElim r) =>
String -> Maybe String -> Maybe Doc -> MixedCall r
CP.call' String
jName

  valFromData :: Maybe Int
-> Maybe Integer
-> VS (JavaCode TypeData)
-> Doc
-> SValue JavaCode
valFromData Maybe Int
p Maybe Integer
i VS (JavaCode TypeData)
t' Doc
d = do
    t <- VS (JavaCode TypeData)
t'
    toState $ on2CodeValues (vd p i) t (toCode d)

instance ValueElim JavaCode where
  valuePrec :: JavaCode Value -> Maybe Int
valuePrec = Value -> Maybe Int
valPrec (Value -> Maybe Int)
-> (JavaCode Value -> Value) -> JavaCode Value -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Value -> Value
forall a. JavaCode a -> a
unJC
  valueInt :: JavaCode Value -> Maybe Integer
valueInt = Value -> Maybe Integer
valInt (Value -> Maybe Integer)
-> (JavaCode Value -> Value) -> JavaCode Value -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Value -> Value
forall a. JavaCode a -> a
unJC
  value :: JavaCode Value -> Doc
value = Value -> Doc
val (Value -> Doc)
-> (JavaCode Value -> Value) -> JavaCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Value -> Value
forall a. JavaCode a -> a
unJC

instance InternalValueExp JavaCode where
  objMethodCallMixedArgs' :: String
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> [SValue JavaCode]
-> NamedArgs JavaCode
-> SValue JavaCode
objMethodCallMixedArgs' String
f VS (JavaCode TypeData)
t SValue JavaCode
o [SValue JavaCode]
ps NamedArgs JavaCode
ns = do
    ob <- SValue JavaCode
o
    mem <- getMethodExcMap
    let tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString (JavaCode Value -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType JavaCode Value
ob)
    modify (maybe id addExceptions (Map.lookup (qualName tp f) mem))
    G.objMethodCall f t o ps ns
  classMethodCallMixedArgs' :: String -> VS (JavaCode TypeData) -> MixedCtorCall JavaCode
classMethodCallMixedArgs' String
f VS (JavaCode TypeData)
t VS (JavaCode TypeData)
c [SValue JavaCode]
ps NamedArgs JavaCode
ns = do
    cls <- VS (JavaCode TypeData)
c
    mem <- getMethodExcMap
    let tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString JavaCode TypeData
cls
    modify (maybe id addExceptions (Map.lookup (qualName tp f) mem))
    CG.classMethodCall f t c ps ns

instance FunctionSym JavaCode where

instance OOFunctionSym JavaCode where
  func :: String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
func = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
(RenderFunction r, ValueElim r, ValueExpression r) =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
G.func
  objAccess :: SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
objAccess = SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
(FunctionElim r, RenderValue r, ValueElim r) =>
SValue r -> VS (r FuncData) -> SValue r
G.objAccess

instance GetSet JavaCode where
  get :: SValue JavaCode -> SVariable JavaCode -> SValue JavaCode
get = SValue JavaCode -> SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *).
(InternalGetSet r, OOFunctionSym r) =>
SValue r -> SVariable r -> SValue r
G.get
  set :: SValue JavaCode
-> SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
set = SValue JavaCode
-> SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(InternalGetSet r, OOFunctionSym r) =>
SValue r -> SVariable r -> SValue r -> SValue r
G.set

instance IndexTranslator JavaCode where
  intToIndex :: SValue JavaCode -> SValue JavaCode
intToIndex = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). SValue r -> SValue r
CP.intToIndex
  indexToInt :: SValue JavaCode -> SValue JavaCode
indexToInt = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). SValue r -> SValue r
CP.indexToInt

instance Reference JavaCode where
  makeRef :: SValue JavaCode -> SValue JavaCode
makeRef = SValue JavaCode -> SValue JavaCode
forall a. a -> a
id
  maybeDeref :: SValue JavaCode -> SValue JavaCode
maybeDeref = SValue JavaCode -> SValue JavaCode
forall a. a -> a
id

instance Array JavaCode where
  arrayElem :: SValue JavaCode -> SValue JavaCode -> SVariable JavaCode
arrayElem = SValue JavaCode -> SValue JavaCode -> SVariable JavaCode
forall (r :: * -> *).
(IndexTranslator r, RenderVariable r, ValueElim r) =>
SValue r -> SValue r -> SVariable r
G.arrayElem
  arrayLength :: SValue JavaCode -> SValue JavaCode
arrayLength SValue JavaCode
arr = SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf (SVariable JavaCode -> SValue JavaCode)
-> SVariable JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
OOVariableSym r =>
SValue r -> SVariable r -> SVariable r
instanceVarAccess SValue JavaCode
arr (String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
var String
"length" VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
int)
  arrayCopy :: SValue JavaCode -> SValue JavaCode
arrayCopy SValue JavaCode
arr = let
    arrTp :: VS (JavaCode TypeData)
arrTp = (JavaCode Value -> JavaCode TypeData)
-> SValue JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Value -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType SValue JavaCode
arr
    in VS (JavaCode TypeData)
-> SValue JavaCode
-> String
-> [SValue JavaCode]
-> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> [SValue r] -> SValue r
objMethodCall VS (JavaCode TypeData)
arrTp SValue JavaCode
arr String
"clone" []

instance List JavaCode where
  listSize :: SValue JavaCode -> SValue JavaCode
listSize = String -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r
C.listSize String
"size"
  listAccess :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
listAccess = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(IndexTranslator r, InternalListFunc r, FunctionElim r,
 RenderFunction r, RenderValue r, TypeElim r, ValueElim r) =>
SValue r -> SValue r -> SValue r
G.listAccess
  indexOf :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
indexOf = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(IndexTranslator r, OOFunctionSym r) =>
String -> SValue r -> SValue r -> SValue r
CP.indexOf String
jIndex

instance ListStatement JavaCode (Doc, Terminator) where
  listAdd :: SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
listAdd = String
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(IndexTranslator r, InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> SValue r -> SValue r -> MS (r stmt)
CG.listAdd String
jListAdd
  listAppend :: SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
listAppend = String
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> SValue r -> MS (r stmt)
CG.listAppend String
jListAdd
  listSet :: SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
listSet SValue JavaCode
list SValue JavaCode
idx SValue JavaCode
vl = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ VS (JavaCode TypeData)
-> SValue JavaCode
-> String
-> [SValue JavaCode]
-> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> [SValue r] -> SValue r
objMethodCall VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void SValue JavaCode
list String
jListSet [SValue JavaCode
idx, SValue JavaCode
vl]

instance Set JavaCode where
  contains :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
contains = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
String -> SValue r -> SValue r -> SValue r
CP.contains String
jContains
  setAdd :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
setAdd = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
jListAdd
  setRemove :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
setRemove = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
jListRemove
  setUnion :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
setUnion = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
jListUnion

instance InternalList JavaCode Block where
  listSlice' :: Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
listSlice' = Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, EmptyStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, Literal r, BooleanExpression r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, ListStatement r stmt, ValueElim r,
 VariableElim r) =>
Maybe (SValue r)
-> Maybe (SValue r)
-> Maybe (SValue r)
-> SVariable r
-> SValue r
-> MS (r block)
M.listSlice

instance InternalGetSet JavaCode where
  getFunc :: SVariable JavaCode -> VS (JavaCode FuncData)
getFunc = SVariable JavaCode -> VS (JavaCode FuncData)
forall (r :: * -> *).
(OOFunctionSym r, VariableElim r) =>
SVariable r -> VS (r FuncData)
G.getFunc
  setFunc :: VS (JavaCode TypeData)
-> SVariable JavaCode -> SValue JavaCode -> VS (JavaCode FuncData)
setFunc = VS (JavaCode TypeData)
-> SVariable JavaCode -> SValue JavaCode -> VS (JavaCode FuncData)
forall (r :: * -> *).
(OOFunctionSym r, VariableElim r) =>
VS (r TypeData) -> SVariable r -> SValue r -> VS (r FuncData)
G.setFunc

instance InternalListFunc JavaCode where
  listAccessFunc :: VS (JavaCode TypeData) -> SValue JavaCode -> VS (JavaCode FuncData)
listAccessFunc = String
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> VS (JavaCode FuncData)
forall (r :: * -> *).
(OOFunctionSym r, TypeElim r) =>
String -> VS (r TypeData) -> SValue r -> VS (r FuncData)
CP.listAccessFunc' String
jListAccess

instance BinderSym JavaCode where
  binder :: String -> VS (JavaCode TypeData) -> VSBinder JavaCode
binder String
nm VS (JavaCode TypeData)
tp = (TypeData -> BinderD) -> JavaCode TypeData -> JavaCode BinderD
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (String -> TypeData -> BinderD
bindFormD String
nm) (JavaCode TypeData -> JavaCode BinderD)
-> VS (JavaCode TypeData) -> VSBinder JavaCode
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VS (JavaCode TypeData)
tp

instance BinderElim JavaCode where
  binderName :: JavaCode BinderD -> String
binderName = BinderD -> String
bindName (BinderD -> String)
-> (JavaCode BinderD -> BinderD) -> JavaCode BinderD -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode BinderD -> BinderD
forall a. JavaCode a -> a
unJC
  binderType :: JavaCode BinderD -> JavaCode TypeData
binderType = (BinderD -> TypeData) -> JavaCode BinderD -> JavaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue BinderD -> TypeData
bindType

instance InternalBinderElim JavaCode where
  binderElim :: JavaCode BinderD -> Doc
binderElim = String -> Doc
text (String -> Doc)
-> (JavaCode BinderD -> String) -> JavaCode BinderD -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinderD -> String
bindName (BinderD -> String)
-> (JavaCode BinderD -> BinderD) -> JavaCode BinderD -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode BinderD -> BinderD
forall a. JavaCode a -> a
unJC

instance RenderFunction JavaCode where
  funcFromData :: Doc -> VS (JavaCode TypeData) -> VS (JavaCode FuncData)
funcFromData Doc
d = (JavaCode TypeData -> JavaCode FuncData)
-> VS (JavaCode TypeData) -> VS (JavaCode FuncData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((TypeData -> FuncData) -> JavaCode TypeData -> JavaCode FuncData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (TypeData -> Doc -> FuncData
`fd` Doc
d))

instance FunctionElim JavaCode where
  functionType :: JavaCode FuncData -> JavaCode TypeData
functionType = (FuncData -> TypeData) -> JavaCode FuncData -> JavaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue FuncData -> TypeData
fType
  function :: JavaCode FuncData -> Doc
function = FuncData -> Doc
funcDoc (FuncData -> Doc)
-> (JavaCode FuncData -> FuncData) -> JavaCode FuncData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode FuncData -> FuncData
forall a. JavaCode a -> a
unJC

instance InternalAssignStmt JavaCode (Doc, Terminator) where
  multiAssign :: [SVariable JavaCode]
-> [SValue JavaCode] -> MS (JavaCode (Doc, Terminator))
multiAssign [SVariable JavaCode]
_ [SValue JavaCode]
_ = String -> MS (JavaCode (Doc, Terminator))
forall a. HasCallStack => String -> a
error (String -> MS (JavaCode (Doc, Terminator)))
-> String -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiAssignError String
jName

instance InternalIOStmt JavaCode (Doc, Terminator) where
  printSt :: Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
printSt Bool
_ Maybe (SValue JavaCode)
_ = SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
SValue r -> SValue r -> MS (r stmt)
CP.printSt

instance InternalControlStmt JavaCode (Doc, Terminator) where
  multiReturn :: [SValue JavaCode] -> MS (JavaCode (Doc, Terminator))
multiReturn [SValue JavaCode]
_ = String -> MS (JavaCode (Doc, Terminator))
forall a. HasCallStack => String -> a
error (String -> MS (JavaCode (Doc, Terminator)))
-> String -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiReturnError String
jName

instance RenderStatement JavaCode (Doc, Terminator) where
  stmt :: MS (JavaCode (Doc, Terminator)) -> MS (JavaCode (Doc, Terminator))
stmt = MS (JavaCode (Doc, Terminator)) -> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.stmt
  loopStmt :: MS (JavaCode (Doc, Terminator)) -> MS (JavaCode (Doc, Terminator))
loopStmt = MS (JavaCode (Doc, Terminator)) -> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.loopStmt
  stmtFromData :: Doc -> Terminator -> MS (JavaCode (Doc, Terminator))
stmtFromData Doc
d Terminator
t = JavaCode (Doc, Terminator) -> MS (JavaCode (Doc, Terminator))
forall a s. a -> State s a
toState (JavaCode (Doc, Terminator) -> MS (JavaCode (Doc, Terminator)))
-> JavaCode (Doc, Terminator) -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ (Doc, Terminator) -> JavaCode (Doc, Terminator)
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc
d, Terminator
t)

instance StatementElim JavaCode (Doc, Terminator) where
  statement :: JavaCode (Doc, Terminator) -> Doc
statement = (Doc, Terminator) -> Doc
forall a b. (a, b) -> a
fst ((Doc, Terminator) -> Doc)
-> (JavaCode (Doc, Terminator) -> (Doc, Terminator))
-> JavaCode (Doc, Terminator)
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (Doc, Terminator) -> (Doc, Terminator)
forall a. JavaCode a -> a
unJC
  statementTerm :: JavaCode (Doc, Terminator) -> Terminator
statementTerm = (Doc, Terminator) -> Terminator
forall a b. (a, b) -> b
snd ((Doc, Terminator) -> Terminator)
-> (JavaCode (Doc, Terminator) -> (Doc, Terminator))
-> JavaCode (Doc, Terminator)
-> Terminator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (Doc, Terminator) -> (Doc, Terminator)
forall a. JavaCode a -> a
unJC

instance EmptyStatement JavaCode (Doc, Terminator) where
  emptyStmt :: MS (JavaCode (Doc, Terminator))
emptyStmt = MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt)
G.emptyStmt

instance MultiStatement JavaCode (Doc, Terminator) where
  multi :: [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
multi = ([JavaCode (Doc, Terminator)] -> JavaCode (Doc, Terminator))
-> [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([(Doc, Terminator)] -> (Doc, Terminator))
-> [JavaCode (Doc, Terminator)] -> JavaCode (Doc, Terminator)
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [(Doc, Terminator)] -> (Doc, Terminator)
R.multiStmt)

instance ValueStatement JavaCode (Doc, Terminator) where
  valStmt :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
valStmt = Terminator -> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
Terminator -> SValue r -> MS (r stmt)
G.valStmt Terminator
Semi

instance AssignStatement JavaCode (Doc, Terminator) where
  assign :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
assign = Terminator
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
Terminator -> SVariable r -> SValue r -> MS (r stmt)
G.assign Terminator
Semi
  &-= :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
(&-=) = Terminator
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
Terminator -> SVariable r -> SValue r -> MS (r stmt)
G.subAssign Terminator
Semi
  &+= :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
(&+=) = SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
SVariable r -> SValue r -> MS (r stmt)
C.increment
  &++ :: SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
(&++) = SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt) =>
SVariable r -> MS (r stmt)
C.increment1
  &-- :: SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
(&--) = SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt) =>
SVariable r -> MS (r stmt)
C.decrement1

instance DeclStatement JavaCode (Doc, Terminator) Body where
  varDec :: SVariable JavaCode
-> JavaCode ScopeData -> MS (JavaCode (Doc, Terminator))
varDec = JavaCode Doc
-> JavaCode Doc
-> Doc
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) attch stmt.
(InternalVarElim r, PermElim r attch, RenderStatement r stmt,
 ScopeElim r, UnRepr r TypeData, TypeElim r, VariableElim r) =>
r attch
-> r attch -> Doc -> SVariable r -> r ScopeData -> MS (r stmt)
C.varDec JavaCode Doc
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel JavaCode Doc
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel Doc
empty
  varDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
varDecDef = Terminator
-> SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r) =>
Terminator -> SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
C.varDecDef Terminator
Semi
  setDec :: SVariable JavaCode
-> JavaCode ScopeData -> MS (JavaCode (Doc, Terminator))
setDec = SVariable JavaCode
-> JavaCode ScopeData -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
varDec
  setDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
setDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
varDecDef
  listDec :: Integer
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
listDec Integer
n SVariable JavaCode
v JavaCode ScopeData
scp = LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
-> SVariable JavaCode
-> StateT MethodState Identity (JavaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode Variable) ValueState)
-> MethodState -> Focusing Identity (JavaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable JavaCode
v StateT MethodState Identity (JavaCode Variable)
-> (JavaCode Variable -> MS (JavaCode (Doc, Terminator)))
-> MS (JavaCode (Doc, Terminator))
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\JavaCode Variable
v' -> (JavaCode Value -> Doc)
-> SValue JavaCode
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, RenderStatement r stmt,
 StatementElim r stmt) =>
(r Value -> Doc)
-> SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
C.listDec (JavaCode Variable -> JavaCode Value -> Doc
forall (r :: * -> *).
(UnRepr r TypeData, ValueElim r, VariableElim r) =>
r Variable -> r Value -> Doc
renderListDec JavaCode Variable
v')
    (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n) SVariable JavaCode
v JavaCode ScopeData
scp)
  listDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
listDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
CP.listDecDef
  arrayDec :: Integer
-> SValue JavaCode
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
arrayDec Integer
n SValue JavaCode
_ = SValue JavaCode
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(ScopeElim r, UnRepr r TypeData, InternalVarElim r,
 RenderStatement r stmt, ValueElim r, VariableElim r) =>
SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
CP.arrayDec (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n)
  arrayDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
arrayDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
CP.arrayDecDef
  constDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
constDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
jConstDecDef
  funcDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
funcDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
jFuncDecDef

instance OODeclStatement JavaCode (Doc, Terminator) Body where
  objDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
objDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
varDecDef
  objDecNew :: SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
objDecNew = SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, OOValueExpression r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
G.objDecNew
  extObjDecNew :: String
-> SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
extObjDecNew = String
-> SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, OOValueExpression r, VariableElim r) =>
String -> SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
C.extObjDecNew

instance PrintConsole JavaCode (Doc, Terminator) where
  print :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
print      = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
False Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc
  printLn :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
printLn    = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
True  Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc
  printStr :: String -> MS (JavaCode (Doc, Terminator))
printStr   = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
False Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc   (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> MS (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printStrLn :: String -> MS (JavaCode (Doc, Terminator))
printStrLn = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
True  Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> MS (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

instance ReadConsole JavaCode (Doc, Terminator) where
  getInput :: SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
getInput SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
v SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  discardInput :: MS (JavaCode (Doc, Terminator))
discardInput = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
jDiscardInput SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc

instance FileHandling JavaCode (Doc, Terminator) where
  openFileR :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
openFileR = (SValue JavaCode -> VS (JavaCode TypeData) -> SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
(SValue r -> VS (r TypeData) -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileR SValue JavaCode -> VS (JavaCode TypeData) -> SValue JavaCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r
jOpenFileR
  openFileW :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
openFileW = (SValue JavaCode
 -> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileW SValue JavaCode
-> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
jOpenFileWorA
  openFileA :: SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
openFileA = (SValue JavaCode
 -> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileA SValue JavaCode
-> VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
jOpenFileWorA
  closeFile :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
closeFile = String -> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> MS (r stmt)
G.closeFile String
jClose

instance PrintFile JavaCode (Doc, Terminator) where
  printFile :: SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
printFile SValue JavaCode
f      = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
False (SValue JavaCode -> Maybe (SValue JavaCode)
forall a. a -> Maybe a
Just SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue JavaCode
f)
  printFileLn :: SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
printFileLn SValue JavaCode
f    = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
True  (SValue JavaCode -> Maybe (SValue JavaCode)
forall a. a -> Maybe a
Just SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue JavaCode
f)
  printFileStr :: SValue JavaCode -> String -> MS (JavaCode (Doc, Terminator))
printFileStr SValue JavaCode
f   = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
False (SValue JavaCode -> Maybe (SValue JavaCode)
forall a. a -> Maybe a
Just SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue JavaCode
f)   (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> MS (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printFileStrLn :: SValue JavaCode -> String -> MS (JavaCode (Doc, Terminator))
printFileStrLn SValue JavaCode
f = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
True  (SValue JavaCode -> Maybe (SValue JavaCode)
forall a. a -> Maybe a
Just SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue JavaCode
f) (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> MS (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

instance ReadFile JavaCode (Doc, Terminator) where
  getFileInput :: SValue JavaCode
-> SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
getFileInput SValue JavaCode
f SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
v SValue JavaCode
f
  discardFileInput :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
discardFileInput = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
jDiscardInput
  getFileInputLine :: SValue JavaCode
-> SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
getFileInputLine SValue JavaCode
f SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SValue JavaCode
f SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc
  discardFileLine :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
discardFileLine = String -> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> MS (r stmt)
CP.discardFileLine String
jNextLine
  getFileInputAll :: SValue JavaCode
-> SVariable JavaCode -> MS (JavaCode (Doc, Terminator))
getFileInputAll SValue JavaCode
f SVariable JavaCode
v = SValue JavaCode
-> MS (JavaCode Doc) -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r bod) -> MS (r stmt)
while (SValue JavaCode
f SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jHasNextLineFunc)
    (MS (JavaCode (Doc, Terminator)) -> MS (JavaCode Doc)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (JavaCode (Doc, Terminator)) -> MS (JavaCode Doc))
-> MS (JavaCode (Doc, Terminator)) -> MS (JavaCode Doc)
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ListStatement r stmt =>
SValue r -> SValue r -> MS (r stmt)
listAppend (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v) (SValue JavaCode
f SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc))

instance StringStatement JavaCode (Doc, Terminator) where
  stringSplit :: Char
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
stringSplit Char
d SVariable JavaCode
vnew SValue JavaCode
s = do
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> MethodState -> MethodState
addLangImport (String -> MethodState -> MethodState)
-> String -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
jArrays)
    ss <- LensLike'
  (Zoomed (StateT ValueState Identity) Doc) MethodState ValueState
-> StateT ValueState Identity Doc
-> StateT MethodState Identity Doc
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) Doc) MethodState ValueState
(ValueState -> Focusing Identity Doc ValueState)
-> MethodState -> Focusing Identity Doc MethodState
Lens' MethodState ValueState
lensMStoVS (StateT ValueState Identity Doc -> StateT MethodState Identity Doc)
-> StateT ValueState Identity Doc
-> StateT MethodState Identity Doc
forall a b. (a -> b) -> a -> b
$
      SVariable JavaCode
-> SValue JavaCode -> StateT ValueState Identity Doc
jStringSplit SVariable JavaCode
vnew (VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string [SValue JavaCode
s SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. Char -> VS (JavaCode FuncData)
forall (r :: * -> *).
(Literal r, OOFunctionSym r) =>
Char -> VS (r FuncData)
jSplitFunc Char
d])
    mkStmt ss

  stringListVals :: [SVariable JavaCode]
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
stringListVals = [SVariable JavaCode]
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(MultiStatement r stmt, AssignStatement r stmt, List r, Literal r,
 RenderValue r, TypeElim r, VariableElim r) =>
[SVariable r] -> SValue r -> MS (r stmt)
M.stringListVals
  stringListLists :: [SVariable JavaCode]
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
stringListLists = [SVariable JavaCode]
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt,
 ControlStatement r stmt bod, Literal r, NumericExpression r,
 VariableValue r, List r, ListStatement r stmt, TypeElim r,
 VariableElim r, RenderValue r) =>
[SVariable r] -> SValue r -> MS (r stmt)
M.stringListLists

instance FuncAppStatement JavaCode (Doc, Terminator) where
  inOutCall :: InOutCall JavaCode (Doc, Terminator)
inOutCall = (String
 -> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode (Doc, Terminator)
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp
  extInOutCall :: String -> InOutCall JavaCode (Doc, Terminator)
extInOutCall String
m = (String
 -> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode (Doc, Terminator)
jInOutCall (String
-> String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> SValue JavaCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
m)

instance OOFuncAppStatement JavaCode (Doc, Terminator) where
  selfInOutCall :: InOutCall JavaCode (Doc, Terminator)
selfInOutCall = (String
 -> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode (Doc, Terminator)
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *).
(InternalValueExp r, VariableValue r, SelfSym r) =>
PosCall r
selfMethodCall

instance CommentStatement JavaCode (Doc, Terminator) where
  comment :: String -> MS (JavaCode (Doc, Terminator))
comment = Doc -> String -> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> String -> MS (r stmt)
G.comment Doc
commentStart

instance ControlStatement JavaCode (Doc, Terminator) Body where
  break :: MS (JavaCode (Doc, Terminator))
break = Doc -> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmt Doc
R.break
  continue :: MS (JavaCode (Doc, Terminator))
continue = Doc -> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmt Doc
R.continue

  returnStmt :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
returnStmt = Terminator -> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
Terminator -> SValue r -> MS (r stmt)
G.returnStmt Terminator
Semi

  throw :: String -> MS (JavaCode (Doc, Terminator))
throw = (JavaCode Value -> Doc)
-> Terminator -> String -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(Literal r, RenderStatement r stmt) =>
(r Value -> Doc) -> Terminator -> String -> MS (r stmt)
G.throw JavaCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
jThrowDoc Terminator
Semi

  ifCond :: [(SValue JavaCode, MS (JavaCode Doc))]
-> MS (JavaCode Doc) -> MS (JavaCode (Doc, Terminator))
ifCond = (Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue JavaCode, MS (JavaCode Doc))]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, ValueElim r) =>
(Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue r, MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
G.ifCond Doc -> Doc
parens Doc
bodyStart OptionalSpace
G.defaultOptSpace Doc
elseIfLabel Doc
bodyEnd Doc
empty
  switch :: SValue JavaCode
-> [(SValue JavaCode, MS (JavaCode Doc))]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
switch  = (Doc -> Doc)
-> MS (JavaCode (Doc, Terminator))
-> SValue JavaCode
-> [(SValue JavaCode, MS (JavaCode Doc))]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r) =>
(Doc -> Doc)
-> MS (r stmt)
-> SValue r
-> [(SValue r, MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
C.switch Doc -> Doc
parens MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
MS (r stmt)
break

  ifExists :: SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
ifExists = SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(ControlStatement r stmt bod, ValueExpression r) =>
SValue r -> MS (r bod) -> MS (r bod) -> MS (r stmt)
M.ifExists

  for :: MS (JavaCode (Doc, Terminator))
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
for = Doc
-> Doc
-> MS (JavaCode (Doc, Terminator))
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r) =>
Doc
-> Doc
-> MS (r stmt)
-> SValue r
-> MS (r stmt)
-> MS (r bod)
-> MS (r stmt)
C.for Doc
bodyStart Doc
bodyEnd
  forRange :: SVariable JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forRange = SVariable JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, Comparison r, VariableValue r) =>
SVariable r
-> SValue r -> SValue r -> SValue r -> MS (r bod) -> MS (r stmt)
M.forRange
  forEach :: SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forEach = Doc
-> Doc
-> Doc
-> Doc
-> SVariable JavaCode
-> SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, InternalVarElim r, RenderStatement r stmt,
 UnRepr r TypeData, ValueElim r, VariableElim r) =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MS (r bod)
-> MS (r stmt)
CP.forEach Doc
bodyStart Doc
bodyEnd Doc
forLabel Doc
colon
  while :: SValue JavaCode
-> MS (JavaCode Doc) -> MS (JavaCode (Doc, Terminator))
while = (Doc -> Doc)
-> Doc
-> Doc
-> SValue JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, ValueElim r) =>
(Doc -> Doc) -> Doc -> Doc -> SValue r -> MS (r bod) -> MS (r stmt)
C.while Doc -> Doc
parens Doc
bodyStart Doc
bodyEnd

  tryCatch :: MS (JavaCode Doc)
-> MS (JavaCode Doc) -> MS (JavaCode (Doc, Terminator))
tryCatch = (JavaCode Doc -> JavaCode Doc -> Doc)
-> MS (JavaCode Doc)
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k) (bod :: k).
RenderStatement r stmt =>
(r bod -> r bod -> Doc) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
G.tryCatch JavaCode Doc -> JavaCode Doc -> Doc
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> r bod -> Doc
jTryCatch

  assert :: SValue JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
assert SValue JavaCode
condition SValue JavaCode
errorMessage = do
    cond <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Value))
  MethodState
  ValueState
-> SValue JavaCode -> StateT MethodState Identity (JavaCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode Value) ValueState)
-> MethodState -> Focusing Identity (JavaCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue JavaCode
condition
    errMsg <- zoom lensMStoVS errorMessage
    mkStmt (jAssert cond errMsg)

instance ObserverPattern JavaCode (Doc, Terminator) where
  notifyObservers :: VS (JavaCode FuncData)
-> VS (JavaCode TypeData) -> MS (JavaCode (Doc, Terminator))
notifyObservers = VS (JavaCode FuncData)
-> VS (JavaCode TypeData) -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 VariableValue r, Comparison r, List r, ValueStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, OOFunctionSym r) =>
VS (r FuncData) -> VS (r TypeData) -> MS (r stmt)
M.notifyObservers

instance StrategyPattern JavaCode Body Block where
  runStrategy :: String
-> [(String, MS (JavaCode Doc))]
-> Maybe (SValue JavaCode)
-> Maybe (SVariable JavaCode)
-> MS (JavaCode Doc)
runStrategy = String
-> [(String, MS (JavaCode Doc))]
-> Maybe (SValue JavaCode)
-> Maybe (SVariable JavaCode)
-> MS (JavaCode Doc)
forall (r :: * -> *) stmt bod.
(EmptyStatement r stmt, AssignStatement r stmt, BodyElim r bod,
 Monad r, RenderStatement r stmt, StatementElim r stmt) =>
String
-> [(String, MS (r bod))]
-> Maybe (SValue r)
-> Maybe (SVariable r)
-> MS (r Doc)
M.runStrategy

instance VisibilitySym JavaCode Doc where
  private :: JavaCode Doc
private = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.private
  public :: JavaCode Doc
public = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.public

instance RenderVisibility JavaCode Doc where
  visibilityFromData :: VisibilityTag -> Doc -> JavaCode Doc
visibilityFromData VisibilityTag
_ = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode

instance VisibilityElim JavaCode Doc where
  visibility :: JavaCode Doc -> Doc
visibility = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance MethodTypeSym JavaCode where
  mType :: VS (JavaCode TypeData) -> MSMthdType JavaCode
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode TypeData))
  MethodState
  ValueState
-> VS (JavaCode TypeData) -> MSMthdType JavaCode
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode TypeData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode TypeData) ValueState)
-> MethodState -> Focusing Identity (JavaCode TypeData) MethodState
Lens' MethodState ValueState
lensMStoVS

instance OOMethodTypeSym JavaCode where
  construct :: String -> MSMthdType JavaCode
construct = String -> MSMthdType JavaCode
forall (r :: * -> *). Monad r => String -> MS (r TypeData)
G.construct

instance ParameterSym JavaCode where
  param :: SVariable JavaCode -> MS (JavaCode ParamData)
param = (JavaCode Variable -> Doc)
-> SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
(RenderParam r, VariableElim r) =>
(r Variable -> Doc) -> SVariable r -> MS (r ParamData)
G.param JavaCode Variable -> Doc
forall (r :: * -> *).
(InternalVarElim r, UnRepr r TypeData, VariableElim r) =>
r Variable -> Doc
renderParam
  pointerParam :: SVariable JavaCode -> MS (JavaCode ParamData)
pointerParam = SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param

instance RenderParam JavaCode where
  paramFromData :: SVariable JavaCode -> Doc -> MS (JavaCode ParamData)
paramFromData SVariable JavaCode
v' Doc
d = do
    v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
-> SVariable JavaCode
-> StateT MethodState Identity (JavaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode Variable) ValueState)
-> MethodState -> Focusing Identity (JavaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable JavaCode
v'
    toState $ on2CodeValues pd v (toCode d)

instance ParamElim JavaCode where
  parameterName :: JavaCode ParamData -> String
parameterName = JavaCode Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> String
variableName (JavaCode Variable -> String)
-> (JavaCode ParamData -> JavaCode Variable)
-> JavaCode ParamData
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable) -> JavaCode ParamData -> JavaCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameterType :: JavaCode ParamData -> JavaCode TypeData
parameterType = JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType (JavaCode Variable -> JavaCode TypeData)
-> (JavaCode ParamData -> JavaCode Variable)
-> JavaCode ParamData
-> JavaCode TypeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable) -> JavaCode ParamData -> JavaCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameter :: JavaCode ParamData -> Doc
parameter = ParamData -> Doc
paramDoc (ParamData -> Doc)
-> (JavaCode ParamData -> ParamData) -> JavaCode ParamData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode ParamData -> ParamData
forall a. JavaCode a -> a
unJC

instance MethodSym JavaCode Doc MethodData Body where
  docMain :: MS (JavaCode Doc) -> MS (JavaCode MethodData)
docMain = MS (JavaCode Doc) -> MS (JavaCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
MS (r bod) -> MS (r mthd)
CP.docMain
  function :: String
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
function = String
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) attch vis mthd bod.
(AttachmentSym r attch, OORenderMethod r vis mthd attch bod) =>
String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
G.function
  mainFunction :: MS (JavaCode Doc) -> MS (JavaCode MethodData)
mainFunction = VS (JavaCode TypeData)
-> String -> MS (JavaCode Doc) -> MS (JavaCode MethodData)
forall (r :: * -> *) attch vis mthd bod.
(AttachmentSym r attch, OORenderMethod r vis mthd attch bod,
 ParameterSym r, UnRepr r TypeData, Monad r, VisibilitySym r vis) =>
VS (r TypeData) -> String -> MS (r bod) -> MS (r mthd)
CP.mainFunction VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string String
mainFunc
  docFunc :: String
-> [String]
-> Maybe String
-> MS (JavaCode MethodData)
-> MS (JavaCode MethodData)
docFunc = String
-> [String]
-> Maybe String
-> MS (JavaCode MethodData)
-> MS (JavaCode MethodData)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
CP.doxFunc

  inOutFunc :: String -> JavaCode Doc -> InOutFunc JavaCode MethodData Doc
inOutFunc String
n JavaCode Doc
s = (VS (JavaCode TypeData)
 -> [MS (JavaCode ParamData)]
 -> MS (JavaCode Doc)
 -> MS (JavaCode MethodData))
-> InOutFunc JavaCode MethodData Doc
forall mthd.
(VS (JavaCode TypeData)
 -> [MS (JavaCode ParamData)]
 -> MS (JavaCode Doc)
 -> MS (JavaCode mthd))
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
jInOut (String
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) vis mthd bod.
MethodSym r vis mthd bod =>
String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
function String
n JavaCode Doc
s)
  docInOutFunc :: String -> JavaCode Doc -> DocInOutFunc JavaCode MethodData Doc
docInOutFunc String
n JavaCode Doc
s = InOutFunc JavaCode MethodData Doc
-> DocInOutFunc JavaCode MethodData Doc
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r Doc)
-> MS (r mthd)
jDocInOut (String -> JavaCode Doc -> InOutFunc JavaCode MethodData Doc
forall (r :: * -> *) vis mthd bod.
MethodSym r vis mthd bod =>
String -> r vis -> InOutFunc r mthd bod
inOutFunc String
n JavaCode Doc
s)

instance OOMethodSym JavaCode Doc MethodData Doc Body where
  method :: String
-> JavaCode Doc
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
method = String
-> JavaCode Doc
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
String
-> r vis
-> r attch
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
G.method
  getMethod :: SVariable JavaCode -> MS (JavaCode MethodData)
getMethod = SVariable JavaCode -> MS (JavaCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
SVariable r -> MS (r mthd)
G.getMethod
  setMethod :: SVariable JavaCode -> MS (JavaCode MethodData)
setMethod = SVariable JavaCode -> MS (JavaCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
SVariable r -> MS (r mthd)
G.setMethod
  constructor :: [MS (JavaCode ParamData)]
-> NamedArgs JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
constructor [MS (JavaCode ParamData)]
ps NamedArgs JavaCode
is MS (JavaCode Doc)
b = MS String
getClassName MS String
-> (String -> MS (JavaCode MethodData)) -> MS (JavaCode MethodData)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\String
n -> String
-> [MS (JavaCode ParamData)]
-> NamedArgs JavaCode
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
String
-> [MS (r ParamData)]
-> Initializers r
-> MS (r bod)
-> MS (r mthd)
CP.constructor String
n [MS (JavaCode ParamData)]
ps NamedArgs JavaCode
is MS (JavaCode Doc)
b)

  inOutMethod :: String
-> JavaCode Doc
-> JavaCode Doc
-> InOutFunc JavaCode MethodData Doc
inOutMethod String
n JavaCode Doc
s JavaCode Doc
p = (VS (JavaCode TypeData)
 -> [MS (JavaCode ParamData)]
 -> MS (JavaCode Doc)
 -> MS (JavaCode MethodData))
-> InOutFunc JavaCode MethodData Doc
forall mthd.
(VS (JavaCode TypeData)
 -> [MS (JavaCode ParamData)]
 -> MS (JavaCode Doc)
 -> MS (JavaCode mthd))
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
jInOut (String
-> JavaCode Doc
-> JavaCode Doc
-> VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OOMethodSym r vis mthd attch bod =>
String
-> r vis
-> r attch
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
method String
n JavaCode Doc
s JavaCode Doc
p)
  docInOutMethod :: String
-> JavaCode Doc
-> JavaCode Doc
-> DocInOutFunc JavaCode MethodData Doc
docInOutMethod String
n JavaCode Doc
s JavaCode Doc
p = InOutFunc JavaCode MethodData Doc
-> DocInOutFunc JavaCode MethodData Doc
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r Doc)
-> MS (r mthd)
jDocInOut (String
-> JavaCode Doc
-> JavaCode Doc
-> InOutFunc JavaCode MethodData Doc
forall (r :: * -> *) vis mthd attch bod.
OOMethodSym r vis mthd attch bod =>
String -> r vis -> r attch -> InOutFunc r mthd bod
inOutMethod String
n JavaCode Doc
s JavaCode Doc
p)

instance RenderMethod JavaCode MethodData where
  commentedFunc :: MS (JavaCode Doc)
-> MS (JavaCode MethodData) -> MS (JavaCode MethodData)
commentedFunc MS (JavaCode Doc)
cmt MS (JavaCode MethodData)
m = (JavaCode MethodData
 -> JavaCode (Doc -> Doc) -> JavaCode MethodData)
-> MS (JavaCode MethodData)
-> State MethodState (JavaCode (Doc -> Doc))
-> MS (JavaCode MethodData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((MethodData -> (Doc -> Doc) -> MethodData)
-> JavaCode MethodData
-> JavaCode (Doc -> Doc)
-> JavaCode MethodData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues MethodData -> (Doc -> Doc) -> MethodData
updateMthd) MS (JavaCode MethodData)
m
    ((JavaCode Doc -> JavaCode (Doc -> Doc))
-> MS (JavaCode Doc) -> State MethodState (JavaCode (Doc -> Doc))
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Doc -> Doc -> Doc) -> JavaCode Doc -> JavaCode (Doc -> Doc)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Doc -> Doc -> Doc
R.commentedItem) MS (JavaCode Doc)
cmt)

  mthdFromData :: VisibilityTag -> Doc -> MS (JavaCode MethodData)
mthdFromData VisibilityTag
_ Doc
d = JavaCode MethodData -> MS (JavaCode MethodData)
forall a s. a -> State s a
toState (JavaCode MethodData -> MS (JavaCode MethodData))
-> JavaCode MethodData -> MS (JavaCode MethodData)
forall a b. (a -> b) -> a -> b
$ MethodData -> JavaCode MethodData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (MethodData -> JavaCode MethodData)
-> MethodData -> JavaCode MethodData
forall a b. (a -> b) -> a -> b
$ String -> Doc -> MethodData
mthd String
"" Doc
d

instance OORenderMethod JavaCode Doc MethodData Doc Body where
  intMethod :: Bool
-> String
-> JavaCode Doc
-> JavaCode Doc
-> MSMthdType JavaCode
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
intMethod Bool
m String
n JavaCode Doc
s JavaCode Doc
p MSMthdType JavaCode
t [MS (JavaCode ParamData)]
ps MS (JavaCode Doc)
b = do
    tp <- MSMthdType JavaCode
t
    pms <- sequence ps
    bd <- b
    mem <- zoom lensMStoVS getMethodExcMap
    es <- getExceptions
    mn <- zoom lensMStoFS getModuleName
    let excs = (ExceptionType -> Exception) -> [ExceptionType] -> [Exception]
forall a b. (a -> b) -> [a] -> [b]
map (JavaCode Exception -> Exception
forall a. JavaCode a -> a
unJC (JavaCode Exception -> Exception)
-> (ExceptionType -> JavaCode Exception)
-> ExceptionType
-> Exception
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptionType -> JavaCode Exception
forall (r :: * -> *).
HasException r =>
ExceptionType -> r Exception
toConcreteExc) ([ExceptionType] -> [Exception]) -> [ExceptionType] -> [Exception]
forall a b. (a -> b) -> a -> b
$ [ExceptionType]
-> ([ExceptionType] -> [ExceptionType])
-> Maybe [ExceptionType]
-> [ExceptionType]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [ExceptionType]
es ([ExceptionType] -> [ExceptionType]
forall a. Eq a => [a] -> [a]
nub ([ExceptionType] -> [ExceptionType])
-> ([ExceptionType] -> [ExceptionType])
-> [ExceptionType]
-> [ExceptionType]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([ExceptionType] -> [ExceptionType] -> [ExceptionType]
forall a. [a] -> [a] -> [a]
++ [ExceptionType]
es))
          (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
mn String
n) Map QualifiedName [ExceptionType]
mem)
    modify ((if m then setCurrMain else id) . addExceptionImports excs)
    pure $ toCode $ mthd n $ jMethod n (map exc excs) s p tp pms bd
  intFunc :: Bool
-> String
-> JavaCode Doc
-> JavaCode Doc
-> MSMthdType JavaCode
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
intFunc = Bool
-> String
-> JavaCode Doc
-> JavaCode Doc
-> MSMthdType JavaCode
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
Bool
-> String
-> r vis
-> r attch
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
intMethod
  destructor :: forall stvr. [CSStateVar JavaCode stvr] -> MS (JavaCode MethodData)
destructor [CSStateVar JavaCode stvr]
_ = String -> MS (JavaCode MethodData)
forall a. HasCallStack => String -> a
error (String -> MS (JavaCode MethodData))
-> String -> MS (JavaCode MethodData)
forall a b. (a -> b) -> a -> b
$ String -> String
CP.destructorError String
jName

instance MethodElim JavaCode MethodData where
  method :: JavaCode MethodData -> Doc
method = MethodData -> Doc
mthdDoc (MethodData -> Doc)
-> (JavaCode MethodData -> MethodData)
-> JavaCode MethodData
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode MethodData -> MethodData
forall a. JavaCode a -> a
unJC

instance StateVarSym JavaCode Doc Doc Doc where
  stateVar :: JavaCode Doc
-> JavaCode Doc -> SVariable JavaCode -> CSStateVar JavaCode Doc
stateVar = JavaCode Doc
-> JavaCode Doc -> SVariable JavaCode -> CSStateVar JavaCode Doc
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(Monad r,
 OORenderSym r vis stmt mthd stvr attch file mod bod block) =>
r vis -> r attch -> SVariable r -> CS (r Doc)
CP.stateVar
  stateVarDef :: JavaCode Doc
-> JavaCode Doc
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode Doc
stateVarDef = JavaCode Doc
-> JavaCode Doc
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode Doc
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 Monad r) =>
r vis -> r attch -> SVariable r -> SValue r -> CS (r Doc)
CP.stateVarDef
  constVar :: JavaCode Doc
-> SVariable JavaCode -> SValue JavaCode -> CSStateVar JavaCode Doc
constVar = Doc
-> JavaCode Doc
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode Doc
forall (r :: * -> *) vis stmt mthd bod block.
(CommonRenderSym r vis stmt mthd bod block, Monad r) =>
Doc -> r vis -> SVariable r -> SValue r -> CS (r Doc)
CP.constVar (JavaCode Doc -> Doc
forall {k} (r :: k -> *) (attch :: k).
PermElim r attch =>
r attch -> Doc
RC.perm (JavaCode Doc
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel :: JavaCode Doc))

instance StateVarElim JavaCode StateVar where
  stateVar :: JavaCode Doc -> Doc
stateVar = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance ClassSym JavaCode Doc MethodData StateVar Doc where
  buildClass :: Maybe String
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
buildClass = Maybe String
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
forall (r :: * -> *) vis mthd stvr.
(RenderClass r vis mthd stvr, VisibilitySym r vis) =>
Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
extraClass = String
-> Maybe String
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
forall (r :: * -> *) vis mthd stvr.
(RenderClass r vis mthd stvr, RenderVisibility r vis) =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
jExtraClass
  implementingClass :: String
-> [String]
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
implementingClass = String
-> [String]
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
forall (r :: * -> *) vis mthd stvr.
(RenderClass r vis mthd stvr, VisibilitySym r vis) =>
String
-> [String]
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
G.implementingClass

  docClass :: String -> CSStateVar JavaCode Doc -> CSStateVar JavaCode Doc
docClass = String -> CSStateVar JavaCode Doc -> CSStateVar JavaCode Doc
forall (r :: * -> *) vis mthd stvr.
RenderClass r vis mthd stvr =>
String -> CS (r Doc) -> CS (r Doc)
CP.doxClass

instance RenderClass JavaCode Doc MethodData StateVar where
  intClass :: String
-> JavaCode Doc
-> JavaCode Doc
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
intClass = (String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> JavaCode Doc
-> JavaCode Doc
-> [CSStateVar JavaCode Doc]
-> [MS (JavaCode MethodData)]
-> [MS (JavaCode MethodData)]
-> CSStateVar JavaCode Doc
forall (r :: * -> *) mthd stvr vis.
(MethodElim r mthd, Monad r, StateVarElim r stvr,
 VisibilityElim r vis) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
CP.intClass String -> Doc -> Doc -> Doc -> Doc -> Doc
R.class'

  inherit :: Maybe String -> JavaCode Doc
inherit Maybe String
n = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> Doc -> JavaCode Doc
forall a b. (a -> b) -> a -> b
$ Doc -> (String -> Doc) -> Maybe String -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty ((Doc
jExtends Doc -> Doc -> Doc
<+>) (Doc -> Doc) -> (String -> Doc) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
text) Maybe String
n
  implements :: [String] -> JavaCode Doc
implements [String]
is = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> Doc -> JavaCode Doc
forall a b. (a -> b) -> a -> b
$ Doc
jImplements Doc -> Doc -> Doc
<+> String -> Doc
text (String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
listSep [String]
is)

  commentedClass :: CSStateVar JavaCode Doc
-> CSStateVar JavaCode Doc -> CSStateVar JavaCode Doc
commentedClass = CSStateVar JavaCode Doc
-> CSStateVar JavaCode Doc -> CSStateVar JavaCode Doc
forall (r :: * -> *).
(BlockCommentElim r, ClassElim r, Monad r) =>
CS (r Doc) -> CS (r Doc) -> CS (r Doc)
G.commentedClass

instance ClassElim JavaCode where
  class' :: JavaCode Doc -> Doc
class' = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance ModuleSym JavaCode ModData MethodData where
  buildModule :: String
-> [String]
-> [MS (JavaCode MethodData)]
-> [CSStateVar JavaCode Doc]
-> FS (JavaCode ModData)
buildModule String
n = String
-> (String -> JavaCode Doc)
-> [String]
-> [MS (JavaCode MethodData)]
-> [CSStateVar JavaCode Doc]
-> FS (JavaCode ModData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 UnRepr r Doc) =>
String
-> (String -> r Doc)
-> [String]
-> [MS (r mthd)]
-> [CS (r Doc)]
-> FS (r mod)
CP.buildModule' String
n String -> JavaCode Doc
forall (r :: * -> *). ImportSym r => String -> r Doc
langImport

instance RenderMod JavaCode ModData where
  modFromData :: String -> FS Doc -> FS (JavaCode ModData)
modFromData String
n = String
-> (Doc -> JavaCode ModData) -> FS Doc -> FS (JavaCode ModData)
forall {k} (r :: k -> *) (mod :: k).
String -> (Doc -> r mod) -> FS Doc -> FS (r mod)
G.modFromData String
n (ModData -> JavaCode ModData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (ModData -> JavaCode ModData)
-> (Doc -> ModData) -> Doc -> JavaCode ModData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> ModData
md String
n)
  updateModuleDoc :: (Doc -> Doc) -> JavaCode ModData -> JavaCode ModData
updateModuleDoc Doc -> Doc
f = (ModData -> ModData) -> JavaCode ModData -> JavaCode ModData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Doc -> Doc) -> ModData -> ModData
updateMod Doc -> Doc
f)

instance ModuleElim JavaCode ModData where
  module' :: JavaCode ModData -> Doc
module' = ModData -> Doc
modDoc (ModData -> Doc)
-> (JavaCode ModData -> ModData) -> JavaCode ModData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode ModData -> ModData
forall a. JavaCode a -> a
unJC

instance BlockCommentSym JavaCode where
  blockComment :: [String] -> JavaCode Doc
blockComment [String]
lns = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> Doc -> JavaCode Doc
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.blockCmt [String]
lns Doc
blockCmtStart Doc
blockCmtEnd
  docComment :: forall a. State a [String] -> State a (JavaCode Doc)
docComment = ([String] -> JavaCode Doc)
-> State a [String] -> State a (JavaCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\[String]
lns -> Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> Doc -> JavaCode Doc
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.docCmt [String]
lns Doc
docCmtStart
    Doc
blockCmtEnd)

instance BlockCommentElim JavaCode where
  blockComment' :: JavaCode Doc -> Doc
blockComment' = JavaCode Doc -> Doc
forall a. JavaCode a -> a
unJC

instance HasException JavaCode where
  toConcreteExc :: ExceptionType -> JavaCode Exception
toConcreteExc ExceptionType
Standard = Exception -> JavaCode Exception
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Exception -> JavaCode Exception)
-> Exception -> JavaCode Exception
forall a b. (a -> b) -> a -> b
$ String -> Exception
stdExc String
exceptionObj
  toConcreteExc ExceptionType
FileNotFound = Exception -> JavaCode Exception
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Exception -> JavaCode Exception)
-> Exception -> JavaCode Exception
forall a b. (a -> b) -> a -> b
$ String -> String -> Exception
exception (String -> String
javaImport String
io) String
jFNFExc
  toConcreteExc ExceptionType
IO = Exception -> JavaCode Exception
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Exception -> JavaCode Exception)
-> Exception -> JavaCode Exception
forall a b. (a -> b) -> a -> b
$ String -> String -> Exception
exception (String -> String
javaImport String
io) String
jIOExc

jName, jVersion :: String
jName :: String
jName = String
"Java"
jVersion :: String
jVersion = String
"14"

jImport :: Label -> Doc
jImport :: String -> Doc
jImport String
n = Doc
importLabel Doc -> Doc -> Doc
<+> String -> Doc
text String
n Doc -> Doc -> Doc
<> Doc
endStatement

jBoolType :: (Monad r) => VS (r TypeData)
jBoolType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jBoolType = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
Boolean String
jBool (String -> Doc
text String
jBool)

jInfileType :: (Monad r) => VS (r TypeData)
jInfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jInfileType = do
  tpf <- CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
InFile String
jScanner Doc
jScanner'
  modifyReturn (addLangImportVS $ utilImport jScanner) tpf

jOutfileType :: (Monad r) => VS (r TypeData)
jOutfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jOutfileType = do
  tpf <- CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
OutFile String
jPrintWriter (String -> Doc
text String
jPrintWriter)
  modifyReturn (addLangImportVS $ ioImport jPrintWriter) tpf

jExtends, jImplements, jFinal, jScanner', jLambdaSep :: Doc
jExtends :: Doc
jExtends = String -> Doc
text String
"extends"
jImplements :: Doc
jImplements = String -> Doc
text String
"implements"
jFinal :: Doc
jFinal = String -> Doc
text String
"final"
jScanner' :: Doc
jScanner' = String -> Doc
text String
jScanner
jLambdaSep :: Doc
jLambdaSep = String -> Doc
text String
"->"

arrayList, jBool, jBool', jInteger, jObject, jScanner, jContains, jPrintWriter,
  jFile, jFileWriter, jIOExc, jFNFExc, jArrays, jSet, jAsList, jSetOf, jStdIn,
  jStdOut, jPrintLn, jEquals, jParseInt, jParseDbl, jParseFloat, jIndex,
  jListAdd, jListRemove, jListUnion, jListAccess, jListSet, jClose, jNext,
  jNextLine, jNextBool, jHasNextLine, jCharAt, jSplit, io, util :: String
arrayList :: String
arrayList = String
"ArrayList"
jBool :: String
jBool = String
"boolean"
jBool' :: String
jBool' = String
"Boolean"
jInteger :: String
jInteger = String
"Integer"
jObject :: String
jObject = String
"Object"
jScanner :: String
jScanner = String
"Scanner"
jContains :: String
jContains = String
"contains"
jPrintWriter :: String
jPrintWriter = String
"PrintWriter"
jFile :: String
jFile = String
"File"
jFileWriter :: String
jFileWriter = String
"FileWriter"
jIOExc :: String
jIOExc = String
"IOException"
jFNFExc :: String
jFNFExc = String
"FileNotFoundException"
jArrays :: String
jArrays = String
"Arrays"
jSet :: String
jSet = String
"Set"
jAsList :: String
jAsList = String
jArrays String -> String -> String
`access` String
"asList"
jSetOf :: String
jSetOf = String
jSet String -> String -> String
`access` String
"of"
jStdIn :: String
jStdIn = String
"in"
jStdOut :: String
jStdOut = String
"out"
jPrintLn :: String
jPrintLn = String
"println"
jEquals :: String
jEquals = String
"equals"
jParseInt :: String
jParseInt = String
jInteger String -> String -> String
`access` String
"parseInt"
jParseDbl :: String
jParseDbl = String
CP.doubleRender String -> String -> String
`access` String
"parseDouble"
jParseFloat :: String
jParseFloat = String
CP.floatRender String -> String -> String
`access` String
"parseFloat"
jIndex :: String
jIndex = String
"indexOf"
jListAdd :: String
jListAdd = String
"add"
jListRemove :: String
jListRemove = String
"remove"
jListUnion :: String
jListUnion = String
"addAll"
jListAccess :: String
jListAccess = String
"get"
jListSet :: String
jListSet = String
"set"
jClose :: String
jClose = String
"close"
jNext :: String
jNext = String
"next"
jNextLine :: String
jNextLine = String
"nextLine"
jNextBool :: String
jNextBool = String
"nextBoolean"
jHasNextLine :: String
jHasNextLine = String
"hasNextLine"
jCharAt :: String
jCharAt = String
"charAt"
jSplit :: String
jSplit = String
"split"
io :: String
io = String
"io"
util :: String
util = String
"util"

javaImport, ioImport, utilImport :: String -> String
javaImport :: String -> String
javaImport = String -> String -> String
access String
"java"
ioImport :: String -> String
ioImport = String -> String
javaImport (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> String
access String
io
utilImport :: String -> String
utilImport = String -> String
javaImport (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> String
access String
util

jSystem :: String -> Doc
jSystem :: String -> Doc
jSystem = String -> Doc
text (String -> Doc) -> (String -> String) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> String
access String
"System"

jUnaryMath :: (Monad r) => String -> VSOp r
jUnaryMath :: forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath = String -> VSOp r
forall (r :: * -> *). Monad r => String -> VSOp r
unOpPrec (String -> VSOp r) -> (String -> String) -> String -> VSOp r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
mathFunc

jListType :: (TypeElim r, UnRepr r TypeData, Monad r) =>
  VS (r TypeData) -> VS (r TypeData)
jListType :: forall (r :: * -> *).
(TypeElim r, UnRepr r TypeData, Monad r) =>
VS (r TypeData) -> VS (r TypeData)
jListType VS (r TypeData)
t = do
  (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
arrayList)
  VS (r TypeData)
t VS (r TypeData)
-> (r TypeData -> VS (r TypeData)) -> VS (r TypeData)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (CodeType -> VS (r TypeData)
jListType' (CodeType -> VS (r TypeData))
-> (r TypeData -> CodeType) -> r TypeData -> VS (r TypeData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType)
  where jListType' :: CodeType -> VS (r TypeData)
jListType' CodeType
Integer = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
List CodeType
Integer)
          String
lstInt (String -> Doc
text String
lstInt)
        jListType' CodeType
Float = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.listType String
arrayList VS (r TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.float
        jListType' CodeType
Double = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.listType String
arrayList VS (r TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.double
        jListType' CodeType
Boolean = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
List CodeType
Boolean) String
lstBool (String -> Doc
text String
lstBool)
        jListType' CodeType
_ = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.listType String
arrayList VS (r TypeData)
t
        lstInt :: String
lstInt = String
arrayList String -> String -> String
`containing` String
jInteger
        lstBool :: String
lstBool = String
arrayList String -> String -> String
`containing` String
jBool'

jSetType :: (TypeElim r, UnRepr r TypeData, Monad r) =>
  VS (r TypeData) -> VS (r TypeData)
jSetType :: forall (r :: * -> *).
(TypeElim r, UnRepr r TypeData, Monad r) =>
VS (r TypeData) -> VS (r TypeData)
jSetType VS (r TypeData)
t = do
  (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
"Set")
  VS (r TypeData)
t VS (r TypeData)
-> (r TypeData -> VS (r TypeData)) -> VS (r TypeData)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (CodeType -> VS (r TypeData)
jSetType' (CodeType -> VS (r TypeData))
-> (r TypeData -> CodeType) -> r TypeData -> VS (r TypeData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType)
  where jSetType' :: CodeType -> VS (r TypeData)
jSetType' CodeType
Integer = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
Set CodeType
Integer)
          String
stInt (String -> Doc
text String
stInt)
        jSetType' CodeType
Float = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.setType String
"Set" VS (r TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.float
        jSetType' CodeType
Double = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.setType String
"Set" VS (r TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.double
        jSetType' CodeType
Boolean = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
Set CodeType
Boolean) String
stBool (String -> Doc
text String
stBool)
        jSetType' CodeType
_ = String -> VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.setType String
"Set" VS (r TypeData)
t
        stInt :: String
stInt = String
"Set" String -> String -> String
`containing` String
jInteger
        stBool :: String
stBool = String
"Set" String -> String -> String
`containing` String
jBool'

jArrayType :: VS (JavaCode TypeData)
jArrayType :: VS (JavaCode TypeData)
jArrayType = VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
arrayType (String -> VS (JavaCode TypeData)
forall (r :: * -> *). OOTypeSym r => String -> VS (r TypeData)
obj String
jObject)

jLitArray :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jLitArray :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jLitArray VS (JavaCode TypeData)
t' [SValue JavaCode]
es' = do
  es <- [SValue JavaCode] -> StateT ValueState Identity [JavaCode Value]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SValue JavaCode]
es'
  lt <- arrayType t'
  mkVal lt (new' <+> renderType lt
    <+> braces (valueList es))

jFileType :: (OOTypeSym r) => VS (r TypeData)
jFileType :: forall (r :: * -> *). OOTypeSym r => VS (r TypeData)
jFileType = do
  tpf <- String -> VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => String -> VS (r TypeData)
obj String
jFile
  modifyReturn (addLangImportVS $ ioImport jFile) tpf

jFileWriterType :: (OOTypeSym r) => VS (r TypeData)
jFileWriterType :: forall (r :: * -> *). OOTypeSym r => VS (r TypeData)
jFileWriterType = do
  tpf <- String -> VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => String -> VS (r TypeData)
obj String
jFileWriter
  modifyReturn (addLangImportVS $ ioImport jFileWriter) tpf

jAsListFunc :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc :: VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc VS (JavaCode TypeData)
t = String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
jAsList (VS (JavaCode TypeData) -> VS (JavaCode TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
listType VS (JavaCode TypeData)
t)

jEqualsFunc :: SValue JavaCode -> VS (JavaCode FuncData)
jEqualsFunc :: SValue JavaCode -> VS (JavaCode FuncData)
jEqualsFunc SValue JavaCode
v = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jEquals VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool [SValue JavaCode
v]

jParseIntFunc :: SValue JavaCode -> SValue JavaCode
jParseIntFunc :: SValue JavaCode -> SValue JavaCode
jParseIntFunc SValue JavaCode
v = String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
jParseInt VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
int [SValue JavaCode
v]

jParseDblFunc :: SValue JavaCode -> SValue JavaCode
jParseDblFunc :: SValue JavaCode -> SValue JavaCode
jParseDblFunc SValue JavaCode
v = String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
jParseDbl VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
double [SValue JavaCode
v]

jParseFloatFunc :: SValue JavaCode -> SValue JavaCode
jParseFloatFunc :: SValue JavaCode -> SValue JavaCode
jParseFloatFunc SValue JavaCode
v = String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
jParseFloat VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
float [SValue JavaCode
v]

jNextFunc :: VS (JavaCode FuncData)
jNextFunc :: VS (JavaCode FuncData)
jNextFunc = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jNext VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string []

jNextLineFunc :: VS (JavaCode FuncData)
jNextLineFunc :: VS (JavaCode FuncData)
jNextLineFunc = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jNextLine VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string []

jNextBoolFunc :: VS (JavaCode FuncData)
jNextBoolFunc :: VS (JavaCode FuncData)
jNextBoolFunc = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jNextBool VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool []

jHasNextLineFunc :: VS (JavaCode FuncData)
jHasNextLineFunc :: VS (JavaCode FuncData)
jHasNextLineFunc = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jHasNextLine VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool []

jCharAtFunc :: VS (JavaCode FuncData)
jCharAtFunc :: VS (JavaCode FuncData)
jCharAtFunc = String
-> VS (JavaCode TypeData)
-> [SValue JavaCode]
-> VS (JavaCode FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jCharAt VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
char [Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
0]

jSplitFunc :: (Literal r, OOFunctionSym r) => Char -> VS (r FuncData)
jSplitFunc :: forall (r :: * -> *).
(Literal r, OOFunctionSym r) =>
Char -> VS (r FuncData)
jSplitFunc Char
d = String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
func String
jSplit (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
listType VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string) [String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
litString [Char
d]]

jEquality :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
jEquality :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
jEquality SValue JavaCode
v1 SValue JavaCode
v2 = SValue JavaCode
v2 SValue JavaCode
-> (JavaCode Value -> SValue JavaCode) -> SValue JavaCode
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> SValue JavaCode
jEquality' (CodeType -> SValue JavaCode)
-> (JavaCode Value -> CodeType)
-> JavaCode Value
-> SValue JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType (JavaCode TypeData -> CodeType)
-> (JavaCode Value -> JavaCode TypeData)
-> JavaCode Value
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode Value -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType
  where jEquality' :: CodeType -> SValue JavaCode
jEquality' CodeType
String = SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
objAccess SValue JavaCode
v1 (SValue JavaCode -> VS (JavaCode FuncData)
jEqualsFunc SValue JavaCode
v2)
        jEquality' CodeType
_ = VSUnOp JavaCode
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r) =>
VSBinOp r -> VS (r TypeData) -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool SValue JavaCode
v1 SValue JavaCode
v2

jLambda :: [r BinderD] -> r Value -> Doc
jLambda :: forall (r :: * -> *). [r BinderD] -> r Value -> Doc
jLambda = String -> [r BinderD] -> r Value -> Doc
forall a. HasCallStack => String -> a
error String
"Lambdas not supported in Java (yet). See #4956 for updates." -- \ps ex -> parens (binderList ps) <+> jLambdaSep <+> RC.value ex

jCast :: VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
jCast :: VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
jCast = StateT ValueState Identity (SValue JavaCode) -> SValue JavaCode
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT ValueState Identity (SValue JavaCode) -> SValue JavaCode)
-> (VS (JavaCode TypeData)
    -> SValue JavaCode -> StateT ValueState Identity (SValue JavaCode))
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> SValue JavaCode
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: (JavaCode TypeData -> JavaCode Value -> SValue JavaCode)
-> VS (JavaCode TypeData)
-> SValue JavaCode
-> StateT ValueState Identity (SValue JavaCode)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues
  (\JavaCode TypeData
t JavaCode Value
v -> CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode Value
-> SValue JavaCode
jCast' (JavaCode TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType JavaCode TypeData
t) (JavaCode TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType (JavaCode TypeData -> CodeType) -> JavaCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$ JavaCode Value -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType JavaCode Value
v) JavaCode TypeData
t JavaCode Value
v)
  where jCast' :: CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode Value
-> SValue JavaCode
jCast' CodeType
Double CodeType
String JavaCode TypeData
_ JavaCode Value
v = SValue JavaCode -> SValue JavaCode
jParseDblFunc (JavaCode Value -> SValue JavaCode
forall a s. a -> State s a
toState JavaCode Value
v)
        jCast' CodeType
Float CodeType
String JavaCode TypeData
_ JavaCode Value
v = SValue JavaCode -> SValue JavaCode
jParseFloatFunc (JavaCode Value -> SValue JavaCode
forall a s. a -> State s a
toState JavaCode Value
v)
        jCast' CodeType
_ CodeType
_ JavaCode TypeData
t JavaCode Value
v = VS (JavaCode TypeData) -> Doc -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal (JavaCode TypeData -> VS (JavaCode TypeData)
forall a s. a -> State s a
toState JavaCode TypeData
t) (Doc -> Doc -> Doc
R.castObj (Doc -> Doc
R.cast (JavaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType JavaCode TypeData
t))
          (JavaCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value JavaCode Value
v))

jConstDecDef :: SVariable JavaCode -> JavaCode ScopeData -> SValue JavaCode ->
  MS (JavaCode (Doc, Terminator))
jConstDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
jConstDecDef SVariable JavaCode
v' JavaCode ScopeData
scp SValue JavaCode
def' = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
-> SVariable JavaCode
-> StateT MethodState Identity (JavaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode Variable) ValueState)
-> MethodState -> Focusing Identity (JavaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable JavaCode
v'
  def <- zoom lensMStoVS def'
  modify $ useVarName $ variableName v
  modify $ setVarScope (variableName v) (scopeData scp)
  mkStmt $ jFinal <+> renderType (variableType v) <+>
    RC.variable v <+> equals <+> RC.value def

jFuncDecDef :: SVariable JavaCode -> JavaCode ScopeData ->
  [SVariable JavaCode] -> MS (JavaCode Body) -> MS (JavaCode (Doc, Terminator))
jFuncDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
jFuncDecDef SVariable JavaCode
v JavaCode ScopeData
scp [SVariable JavaCode]
ps MS (JavaCode Doc)
bod = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
-> SVariable JavaCode
-> StateT MethodState Identity (JavaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode Variable) ValueState)
-> MethodState -> Focusing Identity (JavaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable JavaCode
v
  modify $ useVarName $ variableName vr
  modify $ setVarScope (variableName vr) (scopeData scp)
  pms <- mapM (zoom lensMStoVS) ps
  b <- bod
  mkStmt $ renderType (variableType vr) <+> RC.variable vr <+> equals <+>
    parens (variableList pms) <+> jLambdaSep <+> bodyStart $$ indent (RC.body b)
    $$ bodyEnd

jThrowDoc :: (ValueElim r) => r Value -> Doc
jThrowDoc :: forall (r :: * -> *). ValueElim r => r Value -> Doc
jThrowDoc r Value
errMsg = Doc
throwLabel Doc -> Doc -> Doc
<+> Doc
new' Doc -> Doc -> Doc
<+> Doc
exceptionObj' Doc -> Doc -> Doc
<>
  Doc -> Doc
parens (r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
errMsg)

jTryCatch :: (BodyElim r bod) => r bod -> r bod -> Doc
jTryCatch :: forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> r bod -> Doc
jTryCatch r bod
tb r bod
cb = [Doc] -> Doc
vcat [
  Doc
tryLabel Doc -> Doc -> Doc
<+> Doc
lbrace,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
tb,
  Doc
rbrace Doc -> Doc -> Doc
<+> Doc
catchLabel Doc -> Doc -> Doc
<+> Doc -> Doc
parens (Doc
exceptionObj' Doc -> Doc -> Doc
<+> String -> Doc
text String
"exc") Doc -> Doc -> Doc
<+>
    Doc
lbrace,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
cb,
  Doc
rbrace]

jAssert :: (ValueElim r) => r Value -> r Value -> Doc
jAssert :: forall (r :: * -> *). ValueElim r => r Value -> r Value -> Doc
jAssert r Value
condition r Value
errorMessage = [Doc] -> Doc
vcat [
  String -> Doc
text String
"assert" Doc -> Doc -> Doc
<+> r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
condition Doc -> Doc -> Doc
<+> Doc
colon Doc -> Doc -> Doc
<+> r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
errorMessage
  ]

jOut
  ::
    ( BodySym r bod block
    , BlockSym r block stmt
    , Literal r
    , Comparison r
    , NumericExpression r
    , ValueExpression r
    , VariableValue r
    , List r
    , MultiStatement r stmt
    , DeclStatement r stmt bod
    , AssignStatement r stmt
    , ControlStatement r stmt bod
    , PrintConsole r stmt
    , PrintFile r stmt
    , InternalIOStmt r stmt
    , TypeElim r
    )
  => Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut :: forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, MultiStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, PrintConsole r stmt, PrintFile r stmt,
 InternalIOStmt r stmt, TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
jOut Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
v StateT MethodState Identity (r Value)
-> (r Value -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r stmt)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> StateT MethodState Identity (r stmt)
jOut' (CodeType -> StateT MethodState Identity (r stmt))
-> (r Value -> CodeType)
-> r Value
-> StateT MethodState Identity (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType (r TypeData -> CodeType)
-> (r Value -> r TypeData) -> r Value -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r Value -> r TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType
  where jOut' :: CodeType -> StateT MethodState Identity (r stmt)
jOut' (List (Object String
_)) = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r stmt)
forall (r :: * -> *) block stmt bod.
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt, PrintFile r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod, Literal r,
 NumericExpression r, Comparison r, VariableValue r, List r,
 TypeElim r, InternalIOStmt r stmt) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
G.print Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v
        jOut' (List CodeType
_) = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r stmt)
forall (r :: * -> *) stmt.
InternalIOStmt r stmt =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
printSt Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v
        jOut' (Array CodeType
_) = do
          LensLike'
  (Zoomed (StateT ValueState Identity) ()) MethodState ValueState
-> StateT ValueState Identity () -> StateT MethodState Identity ()
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) ()) MethodState ValueState
Lens' MethodState ValueState
lensMStoVS (StateT ValueState Identity () -> StateT MethodState Identity ())
-> StateT ValueState Identity () -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
jArrays)
          Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r stmt)
forall (r :: * -> *) stmt.
InternalIOStmt r stmt =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
printSt Bool
newLn Maybe (SValue r)
f SValue r
printFn (String -> PosCall r
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
jArrays String
"toString" VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string [SValue r
v])
        jOut' CodeType
_ = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r stmt)
forall (r :: * -> *) block stmt bod.
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt, PrintFile r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod, Literal r,
 NumericExpression r, Comparison r, VariableValue r, List r,
 TypeElim r, InternalIOStmt r stmt) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
G.print Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v

jDiscardInput :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
jDiscardInput :: SValue JavaCode -> MS (JavaCode (Doc, Terminator))
jDiscardInput SValue JavaCode
inFn = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextFunc

jInput :: SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput :: SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
vr SValue JavaCode
inFn = do
  v <- SVariable JavaCode
vr
  let jInput' CodeType
Integer = SValue JavaCode -> SValue JavaCode
jParseIntFunc (SValue JavaCode -> SValue JavaCode)
-> SValue JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc
      jInput' CodeType
Float = SValue JavaCode -> SValue JavaCode
jParseFloatFunc (SValue JavaCode -> SValue JavaCode)
-> SValue JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc
      jInput' CodeType
Double = SValue JavaCode -> SValue JavaCode
jParseDblFunc (SValue JavaCode -> SValue JavaCode)
-> SValue JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc
      jInput' CodeType
Boolean = SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextBoolFunc
      jInput' CodeType
String = SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextLineFunc
      jInput' CodeType
Char = (SValue JavaCode
inFn SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jNextFunc) SValue JavaCode -> VS (JavaCode FuncData) -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. VS (JavaCode FuncData)
jCharAtFunc
      jInput' CodeType
_ = String -> SValue JavaCode
forall a. HasCallStack => String -> a
error String
"Attempt to read value of unreadable type"
  jInput' (getCodeType $ variableType v)

jOpenFileR :: (OOValueExpression r) => SValue r -> VS (r TypeData) -> SValue r
jOpenFileR :: forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r
jOpenFileR SValue r
n VS (r TypeData)
t = PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
t [PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => VS (r TypeData)
jFileType [SValue r
n]]

jOpenFileWorA :: (OOValueExpression r) => SValue r -> VS (r TypeData) ->
  SValue r -> SValue r
jOpenFileWorA :: forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
jOpenFileWorA SValue r
n VS (r TypeData)
t SValue r
wa = PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
t
  [PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => VS (r TypeData)
jFileWriterType [PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => VS (r TypeData)
jFileType [SValue r
n], SValue r
wa]]

jStringSplit :: SVariable JavaCode -> SValue JavaCode -> VS Doc
jStringSplit :: SVariable JavaCode
-> SValue JavaCode -> StateT ValueState Identity Doc
jStringSplit = (JavaCode Variable -> JavaCode Value -> Doc)
-> SVariable JavaCode
-> SValue JavaCode
-> StateT ValueState Identity Doc
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\JavaCode Variable
vnew JavaCode Value
s -> JavaCode Variable -> Doc
forall (r :: * -> *). InternalVarElim r => r Variable -> Doc
RC.variable JavaCode Variable
vnew Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+>
  Doc
new' Doc -> Doc -> Doc
<+> JavaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType (JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType JavaCode Variable
vnew) Doc -> Doc -> Doc
<> Doc -> Doc
parens (JavaCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value JavaCode Value
s))

jMethod :: Label -> [String] -> JavaCode Doc ->
  JavaCode Doc -> JavaCode TypeData ->
  [JavaCode ParamData] -> JavaCode Body -> Doc
jMethod :: String
-> [String]
-> JavaCode Doc
-> JavaCode Doc
-> JavaCode TypeData
-> [JavaCode ParamData]
-> JavaCode Doc
-> Doc
jMethod String
n [String]
es JavaCode Doc
s JavaCode Doc
p JavaCode TypeData
t [JavaCode ParamData]
ps JavaCode Doc
b = [Doc] -> Doc
vcat [
  JavaCode Doc -> Doc
forall {k} (r :: k -> *) (vis :: k).
VisibilityElim r vis =>
r vis -> Doc
RC.visibility JavaCode Doc
s Doc -> Doc -> Doc
<+> JavaCode Doc -> Doc
forall {k} (r :: k -> *) (attch :: k).
PermElim r attch =>
r attch -> Doc
RC.perm JavaCode Doc
p Doc -> Doc -> Doc
<+> JavaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType JavaCode TypeData
t Doc -> Doc -> Doc
<+> String -> Doc
text String
n Doc -> Doc -> Doc
<>
    Doc -> Doc
parens ([JavaCode ParamData] -> Doc
forall (r :: * -> *). ParamElim r => [r ParamData] -> Doc
parameterList [JavaCode ParamData]
ps) Doc -> Doc -> Doc
<+> [String] -> Doc -> Doc
forall a. [a] -> Doc -> Doc
emptyIfNull [String]
es (Doc
throwsLabel Doc -> Doc -> Doc
<+>
    String -> Doc
text (String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
listSep ([String] -> [String]
forall a. Ord a => [a] -> [a]
sort [String]
es))) Doc -> Doc -> Doc
<+> Doc
lbrace,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ JavaCode Doc -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body JavaCode Doc
b,
  Doc
rbrace]

outputs :: SVariable JavaCode
outputs :: SVariable JavaCode
outputs = String -> VS (JavaCode TypeData) -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
var String
"outputs" VS (JavaCode TypeData)
jArrayType

jAssignFromArray :: Integer -> [SVariable JavaCode] -> [MS (JavaCode (Doc, Terminator))]
jAssignFromArray :: Integer
-> [SVariable JavaCode] -> [MS (JavaCode (Doc, Terminator))]
jAssignFromArray Integer
_ [] = []
jAssignFromArray Integer
c (SVariable JavaCode
v:[SVariable JavaCode]
vs) = (SVariable JavaCode
v SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= VS (JavaCode TypeData) -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> SValue r -> SValue r
cast ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
v)
  (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf (SVariable JavaCode -> SValue JavaCode)
-> SVariable JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode -> SValue JavaCode -> SVariable JavaCode
forall (r :: * -> *).
Array r =>
SValue r -> SValue r -> SVariable r
arrayElem (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
outputs) (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
c))) MS (JavaCode (Doc, Terminator))
-> [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer
-> [SVariable JavaCode] -> [MS (JavaCode (Doc, Terminator))]
jAssignFromArray (Integer
cInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1) [SVariable JavaCode]
vs

jInOutCall :: (Label -> VS (JavaCode TypeData) -> [SValue JavaCode] ->
  SValue JavaCode) -> Label -> [SValue JavaCode] -> [SVariable JavaCode] ->
  [SVariable JavaCode] -> MS (JavaCode (Doc, Terminator))
jInOutCall :: (String
 -> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode (Doc, Terminator)
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [] [] = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void [SValue JavaCode]
ins
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [SVariable JavaCode
out] [] = SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable JavaCode
out (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
out)
  [SValue JavaCode]
ins
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [] [SVariable JavaCode
out] = SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable JavaCode
out (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
out)
  (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
out SValue JavaCode -> [SValue JavaCode] -> [SValue JavaCode]
forall a. a -> [a] -> [a]
: [SValue JavaCode]
ins)
jInOutCall String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [SVariable JavaCode]
outs [SVariable JavaCode]
both = [SVariable JavaCode] -> MS (JavaCode (Doc, Terminator))
fCall [SVariable JavaCode]
rets
  where rets :: [SVariable JavaCode]
rets = [SVariable JavaCode]
both [SVariable JavaCode]
-> [SVariable JavaCode] -> [SVariable JavaCode]
forall a. [a] -> [a] -> [a]
++ [SVariable JavaCode]
outs
        fCall :: [SVariable JavaCode] -> MS (JavaCode (Doc, Terminator))
fCall [SVariable JavaCode
x] = SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable JavaCode
x (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
x)
          ((SVariable JavaCode -> SValue JavaCode)
-> [SVariable JavaCode] -> [SValue JavaCode]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [SVariable JavaCode]
both [SValue JavaCode] -> [SValue JavaCode] -> [SValue JavaCode]
forall a. [a] -> [a] -> [a]
++ [SValue JavaCode]
ins)
        fCall [SVariable JavaCode]
xs = MS Bool
isOutputsDeclared MS Bool
-> (Bool -> MS (JavaCode (Doc, Terminator)))
-> MS (JavaCode (Doc, Terminator))
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\Bool
odec -> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
setOutputsDeclared StateT MethodState Identity ()
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode (Doc, Terminator))
forall a b.
StateT MethodState Identity a
-> StateT MethodState Identity b -> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
          [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ((if Bool
odec then SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign else (SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
`varDecDef` JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local)) SVariable JavaCode
outputs
          (String
-> VS (JavaCode TypeData) -> [SValue JavaCode] -> SValue JavaCode
f String
n VS (JavaCode TypeData)
jArrayType ((SVariable JavaCode -> SValue JavaCode)
-> [SVariable JavaCode] -> [SValue JavaCode]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [SVariable JavaCode]
both [SValue JavaCode] -> [SValue JavaCode] -> [SValue JavaCode]
forall a. [a] -> [a] -> [a]
++ [SValue JavaCode]
ins)) MS (JavaCode (Doc, Terminator))
-> [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer
-> [SVariable JavaCode] -> [MS (JavaCode (Doc, Terminator))]
jAssignFromArray Integer
0 [SVariable JavaCode]
xs))

jInOut :: (VS (JavaCode TypeData) -> [MS (JavaCode ParamData)] ->
  MS (JavaCode Body) -> MS (JavaCode mthd)) -> [SVariable JavaCode] ->
  [SVariable JavaCode] -> [SVariable JavaCode] -> MS (JavaCode Body) ->
  MS (JavaCode mthd)
jInOut :: forall mthd.
(VS (JavaCode TypeData)
 -> [MS (JavaCode ParamData)]
 -> MS (JavaCode Doc)
 -> MS (JavaCode mthd))
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> [SVariable JavaCode]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
jInOut VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f [SVariable JavaCode]
ins [] [] MS (JavaCode Doc)
b = VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f VS (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void ((SVariable JavaCode -> MS (JavaCode ParamData))
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param [SVariable JavaCode]
ins) MS (JavaCode Doc)
b
jInOut VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f [SVariable JavaCode]
ins [SVariable JavaCode
v] [] MS (JavaCode Doc)
b = VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
v) ((SVariable JavaCode -> MS (JavaCode ParamData))
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param [SVariable JavaCode]
ins)
  ((JavaCode (Doc, Terminator)
 -> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
forall a b c d s.
(a -> b -> c -> d)
-> State s a -> State s b -> State s c -> State s d
on3StateValues (((Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc)
-> JavaCode (Doc, Terminator)
-> JavaCode Doc
-> JavaCode (Doc, Terminator)
-> JavaCode Doc
forall (r :: * -> *) a b c d.
Applicative r =>
(a -> b -> c -> d) -> r a -> r b -> r c -> r d
on3CodeValues (Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc
surroundBody) (SVariable JavaCode
-> JavaCode ScopeData -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
varDec SVariable JavaCode
v JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local) MS (JavaCode Doc)
b (SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$
  SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f [SVariable JavaCode]
ins [] [SVariable JavaCode
v] MS (JavaCode Doc)
b = VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f ((JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
v)
  ((SVariable JavaCode -> MS (JavaCode ParamData))
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param ([SVariable JavaCode] -> [MS (JavaCode ParamData)])
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode
v SVariable JavaCode -> [SVariable JavaCode] -> [SVariable JavaCode]
forall a. a -> [a] -> [a]
: [SVariable JavaCode]
ins) ((JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((Doc -> (Doc, Terminator) -> Doc)
-> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues Doc -> (Doc, Terminator) -> Doc
appendToBody) MS (JavaCode Doc)
b
  (SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f [SVariable JavaCode]
ins [SVariable JavaCode]
outs [SVariable JavaCode]
both MS (JavaCode Doc)
b = VS (JavaCode TypeData)
-> [MS (JavaCode ParamData)]
-> MS (JavaCode Doc)
-> MS (JavaCode mthd)
f ([SVariable JavaCode] -> VS (JavaCode TypeData)
returnTp [SVariable JavaCode]
rets)
  ((SVariable JavaCode -> MS (JavaCode ParamData))
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> MS (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param ([SVariable JavaCode] -> [MS (JavaCode ParamData)])
-> [SVariable JavaCode] -> [MS (JavaCode ParamData)]
forall a b. (a -> b) -> a -> b
$ [SVariable JavaCode]
both [SVariable JavaCode]
-> [SVariable JavaCode] -> [SVariable JavaCode]
forall a. [a] -> [a] -> [a]
++ [SVariable JavaCode]
ins) ((JavaCode (Doc, Terminator)
 -> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
-> MS (JavaCode (Doc, Terminator))
-> MS (JavaCode Doc)
forall a b c d s.
(a -> b -> c -> d)
-> State s a -> State s b -> State s c -> State s d
on3StateValues (((Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc)
-> JavaCode (Doc, Terminator)
-> JavaCode Doc
-> JavaCode (Doc, Terminator)
-> JavaCode Doc
forall (r :: * -> *) a b c d.
Applicative r =>
(a -> b -> c -> d) -> r a -> r b -> r c -> r d
on3CodeValues (Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc
surroundBody) MS (JavaCode (Doc, Terminator))
decls
  MS (JavaCode Doc)
b ([SVariable JavaCode] -> MS (JavaCode (Doc, Terminator))
returnSt [SVariable JavaCode]
rets))
  where returnTp :: [SVariable JavaCode] -> VS (JavaCode TypeData)
returnTp [SVariable JavaCode
x] = (JavaCode Variable -> JavaCode TypeData)
-> SVariable JavaCode -> VS (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode Variable -> JavaCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable JavaCode
x
        returnTp [SVariable JavaCode]
_ = VS (JavaCode TypeData)
jArrayType
        returnSt :: [SVariable JavaCode] -> MS (JavaCode (Doc, Terminator))
returnSt [SVariable JavaCode
x] = SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SValue JavaCode -> MS (JavaCode (Doc, Terminator)))
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
x
        returnSt [SVariable JavaCode]
_ = [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi (Integer
-> SValue JavaCode
-> SVariable JavaCode
-> JavaCode ScopeData
-> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
Integer -> SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
arrayDec (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ [SVariable JavaCode] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SVariable JavaCode]
rets) SValue JavaCode
forall a. HasCallStack => a
undefined SVariable JavaCode
outputs JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local
          MS (JavaCode (Doc, Terminator))
-> [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SValue JavaCode] -> [MS (JavaCode (Doc, Terminator))]
assignArray Integer
0 ((SVariable JavaCode -> SValue JavaCode)
-> [SVariable JavaCode] -> [SValue JavaCode]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [SVariable JavaCode]
rets)
          [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
forall a. [a] -> [a] -> [a]
++ [SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
outputs)])
        assignArray :: Integer -> [SValue JavaCode] -> [MS (JavaCode (Doc, Terminator))]
        assignArray :: Integer -> [SValue JavaCode] -> [MS (JavaCode (Doc, Terminator))]
assignArray Integer
_ [] = []
        assignArray Integer
c (SValue JavaCode
v:[SValue JavaCode]
vs) =
          (SValue JavaCode -> SValue JavaCode -> SVariable JavaCode
forall (r :: * -> *).
Array r =>
SValue r -> SValue r -> SVariable r
arrayElem (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
outputs) (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
c) SVariable JavaCode
-> SValue JavaCode -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SValue JavaCode
v)
          MS (JavaCode (Doc, Terminator))
-> [MS (JavaCode (Doc, Terminator))]
-> [MS (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SValue JavaCode] -> [MS (JavaCode (Doc, Terminator))]
assignArray (Integer
cInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1) [SValue JavaCode]
vs
        decls :: MS (JavaCode (Doc, Terminator))
decls = [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([MS (JavaCode (Doc, Terminator))]
 -> MS (JavaCode (Doc, Terminator)))
-> [MS (JavaCode (Doc, Terminator))]
-> MS (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ (SVariable JavaCode -> MS (JavaCode (Doc, Terminator)))
-> [SVariable JavaCode] -> [MS (JavaCode (Doc, Terminator))]
forall a b. (a -> b) -> [a] -> [b]
map (SVariable JavaCode
-> JavaCode ScopeData -> MS (JavaCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
`varDec` JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local) [SVariable JavaCode]
outs
        rets :: [SVariable JavaCode]
rets = [SVariable JavaCode]
both [SVariable JavaCode]
-> [SVariable JavaCode] -> [SVariable JavaCode]
forall a. [a] -> [a] -> [a]
++ [SVariable JavaCode]
outs

jDocInOut :: (RenderMethod r mthd) => ([SVariable r] ->
  [SVariable r] -> [SVariable r] -> MS (r Body) -> MS (r mthd)) -> String ->
  [(String, SVariable r)] -> [(String, SVariable r)] ->
  [(String, SVariable r)] -> MS (r Body) -> MS (r mthd)
jDocInOut :: forall (r :: * -> *) mthd.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r Doc)
-> MS (r mthd)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [] [] MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst [(String, SVariable r)]
is) []
  ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) [] [] MS (r Doc)
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)
o] [] MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst [(String, SVariable r)]
is)
  [(String, SVariable r) -> String
forall a b. (a, b) -> a
fst (String, SVariable r)
o] ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) [(String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd (String, SVariable r)
o] [] MS (r Doc)
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [] [(String, SVariable r)
both] MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ((String, SVariable r)
both (String, SVariable r)
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. a -> [a] -> [a]
:
  [(String, SVariable r)]
is)) [(String, SVariable r) -> String
forall a b. (a, b) -> a
fst (String, SVariable r)
both] ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) [] [(String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd (String, SVariable r)
both] MS (r Doc)
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr  FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ([(String, SVariable r)] -> [String])
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> a -> b
$ [(String, SVariable r)]
bs [(String, SVariable r)]
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. [a] -> [a] -> [a]
++ [(String, SVariable r)]
is)
  [String]
rets ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
os) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
bs) MS (r Doc)
b)
  where rets :: [String]
rets = String
"array containing the following values:" String -> [String] -> [String]
forall a. a -> [a] -> [a]
: ((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst [(String, SVariable r)]
bs [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
          ((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst [(String, SVariable r)]
os

jExtraClass
  :: (RenderClass r vis mthd stvr, RenderVisibility r vis)
  => Label -> Maybe Label -> [CSStateVar r stvr] -> [MS (r mthd)] -> [MS (r mthd)] -> CS (r Class)
jExtraClass :: forall (r :: * -> *) vis mthd stvr.
(RenderClass r vis mthd stvr, RenderVisibility r vis) =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
jExtraClass String
n = String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
forall (r :: * -> *) vis mthd stvr.
RenderClass r vis mthd stvr =>
String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
intClass String
n (VisibilityTag -> Doc -> r vis
forall {k} (r :: k -> *) (vis :: k).
RenderVisibility r vis =>
VisibilityTag -> Doc -> r vis
visibilityFromData VisibilityTag
Priv Doc
empty) (r Doc
 -> [CSStateVar r stvr]
 -> [MS (r mthd)]
 -> [MS (r mthd)]
 -> CS (r Doc))
-> (Maybe String -> r Doc)
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> r Doc
forall (r :: * -> *) vis mthd stvr.
RenderClass r vis mthd stvr =>
Maybe String -> r Doc
inherit

addCallExcsCurrMod :: String -> VS ()
addCallExcsCurrMod :: String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n = do
  cm <- LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
-> StateT FileState Identity String
-> StateT ValueState Identity String
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) ValueState FileState
-> StateT FileState Identity c -> StateT ValueState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
(FileState -> Focusing Identity String FileState)
-> ValueState -> Focusing Identity String ValueState
Lens' ValueState FileState
lensVStoFS StateT FileState Identity String
getModuleName
  mem <- getMethodExcMap
  modify (maybe id addExceptions (Map.lookup (qualName cm n) mem))

addConstructorCallExcsCurrMod :: (UnRepr r TypeData) =>
  VS (r TypeData) -> (VS (r TypeData) -> SValue r) -> SValue r
addConstructorCallExcsCurrMod :: forall (r :: * -> *).
UnRepr r TypeData =>
VS (r TypeData) -> (VS (r TypeData) -> SValue r) -> SValue r
addConstructorCallExcsCurrMod VS (r TypeData)
ot VS (r TypeData) -> SValue r
f = do
  t <- VS (r TypeData)
ot
  cm <- zoom lensVStoFS getModuleName
  mem <- getMethodExcMap
  let tp = r TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString r TypeData
t
  modify (maybe id addExceptions (Map.lookup (qualName cm tp) mem))
  f (pure t)