{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PostfixOperators #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}

-- | 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(..), SharedProg, Label, MSBody,
  VSType, VSFunction, SVariable, SValue, MSStatement, MSParameter, SMethod,
  BodySym(..), oneLiner, BlockSym(..), TypeSym(..), getCodeType, getTypeString,
  VariableSym(..), VisibilitySym(..), VariableElim(..),ValueSym(..),
  Argument(..), Literal(..), litZero, MathConstant(..), VariableValue(..),
  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
  Comparison(..), ValueExpression(..), funcApp, extFuncApp, IndexTranslator(..),
  Array(..), List(..), Set(..), InternalList(..), ThunkSym(..), VectorType(..),
  VectorDecl(..), VectorThunk(..), VectorExpression(..), ThunkAssign(..),
  StatementSym(..), AssignStatement(..), (&=), DeclStatement(..),
  IOStatement(..), StringStatement(..), FunctionSym(..), FuncAppStatement(..),
  CommentStatement(..), BinderSym(..), BinderElim(..), ControlStatement(..),
  ScopeSym(..), ParameterSym(..), MethodSym(..))
import Drasil.GOOL.InterfaceGOOL (SClass, CSStateVar, OOProg, ProgramSym(..),
  FileSym(..), ModuleSym(..), ClassSym(..), OOTypeSym(..), OOVariableSym(..),
  SelfSym(..), InstanceVarSelfSym(..), StateVarSym(..), AttachmentSym(..),
  OOValueSym, OOVariableValue, OOValueExpression(..), objMethodCall, selfFuncApp,
  newObj, InternalValueExp(..), OOFunctionSym(..), ($.), GetSet(..),
  OODeclStatement(..), OOFuncAppStatement(..), ObserverPattern(..),
  StrategyPattern(..), OOMethodSym(..))
import Drasil.Shared.RendererClassesCommon (CommonRenderSym, ImportSym(..),
  ImportElim, 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 (import', 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 (dot, 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, intValue, 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, listInnerType, 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, selfFuncAppMixedArgs, newObjMixedArgs, lambda,
  func, get, set, listAdd, listAppend, listAccess, listSet, getFunc, setFunc,
  listAppendFunc, 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, intFunc, 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)
import Drasil.Shared.AST (Terminator(..), VisibilityTag(..), qualName,
  FileType(..), FileData(..), fileD, FuncData(..), fd, ModData(..), md,
  updateMod, MethodData(..), mthd, updateMthd, OpData(..), ParamData(..), pd,
  ProgData(..), progD, TypeData(..), ValData(..), vd, VarData(..), vard,
  CommonThunk, pureValue, vectorize, vectorize2, sumComponents, commonVecIndex,
  commonThunkElim, commonThunkDim, ScopeData, BinderD(..), bindFormD)
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 (VS, lensGStoFS, lensMStoFS, lensMStoVS, lensVStoFS,
  lensVStoMS, modifyReturn, modifyReturnList, revFiles, addProgNameToPaths,
  addLangImport, addLangImportVS, addExceptionImports, getModuleName,
  setFileType, getClassName, setCurrMain, setOutputsDeclared,
  isOutputsDeclared, getExceptions, getMethodExcMap, addExceptions, useVarName,
  genLoopIndex, 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 SharedProg JavaCode
instance OOProg JavaCode

instance ProgramSym JavaCode where
  type Program JavaCode = ProgData
  prog :: String -> String -> [SFile JavaCode] -> GSProgram JavaCode
prog String
n String
st [SFile JavaCode]
fs = [State GOOLState (JavaCode FileData)]
-> (GOOLState -> GOOLState)
-> ([JavaCode FileData] -> JavaCode ProgData)
-> State GOOLState (JavaCode ProgData)
forall s b a. [State s b] -> (s -> s) -> ([b] -> a) -> State s a
modifyReturnList ((StateT FileState Identity (JavaCode FileData)
 -> State GOOLState (JavaCode FileData))
-> [StateT FileState Identity (JavaCode FileData)]
-> [State GOOLState (JavaCode FileData)]
forall a b. (a -> b) -> [a] -> [b]
map (LensLike'
  (Zoomed (StateT FileState Identity) (JavaCode FileData))
  GOOLState
  FileState
-> StateT FileState Identity (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) [StateT FileState Identity (JavaCode FileData)]
[SFile JavaCode]
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
instance OORenderSym JavaCode

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

instance FileSym JavaCode where
  type File JavaCode = FileData
  fileDoc :: FSModule JavaCode -> SFile JavaCode
fileDoc FSModule JavaCode
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 (Module JavaCode) -> JavaCode (Block JavaCode))
-> JavaCode (Block JavaCode)
-> FSModule JavaCode
-> SFile JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> (r (Module r) -> r (Block r))
-> r (Block r)
-> FSModule r
-> SFile r
G.fileDoc String
jExt JavaCode (Module JavaCode) -> JavaCode (Block JavaCode)
forall (r :: * -> *). RenderFile r => r (Module r) -> r (Block r)
top JavaCode (Block JavaCode)
forall (r :: * -> *). RenderFile r => r (Block r)
bottom FSModule JavaCode
m

  docMod :: String
-> String -> [String] -> String -> SFile JavaCode -> SFile JavaCode
docMod = String
-> String
-> String
-> [String]
-> String
-> SFile JavaCode
-> SFile JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> String -> String -> [String] -> String -> SFile r -> SFile r
CP.doxMod String
jExt

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

  commentedMod :: SFile JavaCode -> FS (JavaCode Doc) -> SFile JavaCode
commentedMod = (JavaCode FileData -> JavaCode Doc -> JavaCode FileData)
-> StateT FileState Identity (JavaCode FileData)
-> FS (JavaCode Doc)
-> StateT FileState Identity (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 -> FSModule JavaCode -> SFile JavaCode
fileFromData = (String -> JavaCode (Module JavaCode) -> JavaCode (File JavaCode))
-> String -> FSModule JavaCode -> SFile JavaCode
forall (r :: * -> *).
OORenderSym r =>
(String -> r (Module r) -> r (File r))
-> String -> FSModule r -> SFile r
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
  type Import JavaCode = Doc
  langImport :: String -> JavaCode (Import JavaCode)
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 (Import JavaCode)
modImport = String -> JavaCode (Import JavaCode)
forall (r :: * -> *). ImportSym r => String -> r (Import r)
langImport

instance ImportElim JavaCode where
  import' :: JavaCode (Import JavaCode) -> Doc
import' = JavaCode Doc -> Doc
JavaCode (Import JavaCode) -> Doc
forall a. JavaCode a -> a
unJC

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

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

instance BodySym JavaCode where
  type Body JavaCode = Doc
  body :: [MSBlock JavaCode] -> MSBody JavaCode
body = ([JavaCode Doc] -> JavaCode Doc)
-> [State MethodState (JavaCode Doc)]
-> State MethodState (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 -> MSBody JavaCode -> MSBody JavaCode
addComments String
s = (JavaCode Doc -> JavaCode Doc)
-> State MethodState (JavaCode Doc)
-> State MethodState (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 where
  multiBody :: [MSBody JavaCode] -> MSBody JavaCode
multiBody = [MSBody JavaCode] -> State MethodState (JavaCode Doc)
[MSBody JavaCode] -> MSBody JavaCode
forall (r :: * -> *).
(CommonRenderSym r, Monad r) =>
[MSBody r] -> MS (r Doc)
G.multiBody

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

instance BlockSym JavaCode where
  type Block JavaCode = Doc
  block :: [MSStatement JavaCode] -> MSBlock JavaCode
block = [MSStatement JavaCode] -> State MethodState (JavaCode Doc)
[MSStatement JavaCode] -> MSBlock JavaCode
forall (r :: * -> *).
(CommonRenderSym r, Monad r) =>
[MSStatement r] -> MS (r Doc)
G.block

instance RenderBlock JavaCode where
  multiBlock :: [MSBlock JavaCode] -> MSBlock JavaCode
multiBlock = [MSBlock JavaCode] -> State MethodState (JavaCode Doc)
[MSBlock JavaCode] -> MSBlock JavaCode
forall (r :: * -> *).
(CommonRenderSym r, Monad r) =>
[MSBlock r] -> MS (r Doc)
G.multiBlock

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

instance TypeSym JavaCode where
  bool :: VSType JavaCode
bool = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
jBoolType
  int :: VSType JavaCode
int = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
CP.int
  float :: VSType JavaCode
float = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
C.float
  double :: VSType JavaCode
double = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
C.double
  char :: VSType JavaCode
char = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
C.char
  string :: VSType JavaCode
string = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
CP.string'
  infile :: VSType JavaCode
infile = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
jInfileType
  outfile :: VSType JavaCode
outfile = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
jOutfileType
  listType :: VSType JavaCode -> VSType JavaCode
listType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
(UnRepr r TypeData, Monad r) =>
VSType r -> VSType r
jListType
  setType :: VSType JavaCode -> VSType JavaCode
setType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
(UnRepr r TypeData, Monad r) =>
VSType r -> VSType r
jSetType
  arrayType :: VSType JavaCode -> VSType JavaCode
arrayType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
(UnRepr r TypeData, Monad r) =>
VSType r -> VSType r
CP.arrayType
  listInnerType :: VSType JavaCode -> VSType JavaCode
listInnerType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData) =>
VSType r -> VSType r
G.listInnerType
  funcType :: [VSType JavaCode] -> VSType JavaCode -> VSType JavaCode
funcType = [VSType JavaCode] -> VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
[VSType r] -> VSType r -> VSType r
CS.funcType -- TODO [Brandon Bosman, 05/11/2026]: fix this to work with lambda types
  void :: VSType JavaCode
void = VSType JavaCode
forall (r :: * -> *). Monad r => VSType r
C.void

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

instance RenderType JavaCode where
  multiType :: [VSType JavaCode] -> VSType JavaCode
multiType [VSType JavaCode]
_ = String -> VSType JavaCode
forall a. HasCallStack => String -> a
error (String -> VSType JavaCode) -> String -> VSType JavaCode
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
  type Variable JavaCode = VarData
  var :: String -> VSType JavaCode -> SVariable JavaCode
var         = String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String -> VSType r -> SVariable r
G.var
  constant :: String -> VSType JavaCode -> SVariable JavaCode
constant    = String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VSType r -> SVariable r
var
  extVar :: String -> String -> VSType JavaCode -> SVariable JavaCode
extVar      = String -> String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String -> String -> VSType r -> SVariable r
CS.extVar

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

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

instance InstanceVarSelfSym JavaCode where
  instanceVarSelf :: SVariable JavaCode -> SVariable JavaCode
instanceVarSelf = SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *). OORenderSym r => SVariable r -> SVariable r
CP.instanceVarSelf

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

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

instance RenderVariable JavaCode where
  varFromData :: AttachmentTag
-> String -> VSType JavaCode -> Doc -> SVariable JavaCode
varFromData AttachmentTag
b String
n VSType JavaCode
t' Doc
d =  do
    JavaCode TypeData
t <- VSType JavaCode
t'
    JavaCode VarData -> State ValueState (JavaCode VarData)
forall a s. a -> State s a
toState (JavaCode VarData -> State ValueState (JavaCode VarData))
-> JavaCode VarData -> State ValueState (JavaCode VarData)
forall a b. (a -> b) -> a -> b
$ (TypeData -> Doc -> VarData)
-> JavaCode TypeData -> JavaCode Doc -> JavaCode VarData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues (AttachmentTag -> String -> TypeData -> Doc -> VarData
vard AttachmentTag
b String
n) JavaCode TypeData
t (Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)

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

instance OOValueSym JavaCode

instance Argument JavaCode where
  pointerArg :: SValue JavaCode -> SValue JavaCode
pointerArg = VS (JavaCode ValData) -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode
forall a. a -> a
id

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

  litList :: VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
litList VSType JavaCode
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 [VS (JavaCode ValData)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [VS (JavaCode ValData)]
[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)
    VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj (VSType JavaCode -> VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType VSType JavaCode
t) [VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc VSType JavaCode
t [SValue JavaCode]
es | Bool -> Bool
not ([VS (JavaCode ValData)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [VS (JavaCode ValData)]
[SValue JavaCode]
es)]

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

instance VariableValue JavaCode where
  valueOf :: SVariable JavaCode -> SValue JavaCode
valueOf = SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). CommonRenderSym 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 :: * -> *).
CommonRenderSym 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 :: * -> *). CommonRenderSym 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 :: * -> *).
CommonRenderSym 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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
CommonRenderSym 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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SValue r
G.csc
  sec :: SValue JavaCode -> SValue JavaCode
sec = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SValue r
G.sec
  cot :: SValue JavaCode -> SValue JavaCode
cot = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SValue r
G.cot
  arcsin :: SValue JavaCode -> SValue JavaCode
arcsin = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
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 :: * -> *).
CommonRenderSym 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 :: * -> *).
CommonRenderSym 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
-> VSType JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSUnOp r -> VSType r -> SValue r -> SValue r
typeUnExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
notOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?&& :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?&&) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?|| :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?||) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
orOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool

instance Comparison JavaCode where
  ?< :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?<) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?<= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?<=) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?> :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?>= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>=) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterEqualOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?== :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?==) = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
jEquality
  ?!= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?!=) = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
notEqualOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
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 :: * -> *).
CommonRenderSym 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 VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n
    MixedCall JavaCode
forall (r :: * -> *). CommonRenderSym r => MixedCall r
G.funcAppMixedArgs String
n VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns
  extFuncAppMixedArgs :: String -> MixedCall JavaCode
extFuncAppMixedArgs String
l String
n VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
l String
n) Map QualifiedName [ExceptionType]
mem))
    String -> MixedCall JavaCode
forall (r :: * -> *). CommonRenderSym r => String -> MixedCall r
CS.extFuncAppMixedArgs String
l String
n VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns
  libFuncAppMixedArgs :: String -> MixedCall JavaCode
libFuncAppMixedArgs = String -> MixedCall JavaCode
forall (r :: * -> *). CommonRenderSym r => String -> MixedCall r
C.libFuncAppMixedArgs

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

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

instance OOValueExpression JavaCode where
  selfFuncAppMixedArgs :: MixedCall JavaCode
selfFuncAppMixedArgs String
n VSType JavaCode
t [SValue JavaCode]
ps NamedArgs JavaCode
ns = do
    String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n
    Doc -> SVariable JavaCode -> MixedCall JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Doc -> SVariable r -> MixedCall r
G.selfFuncAppMixedArgs Doc
dot SVariable JavaCode
forall (r :: * -> *). SelfSym r => SVariable r
self String
n VSType JavaCode
t [SValue JavaCode]
ps NamedArgs JavaCode
ns
  newObjMixedArgs :: MixedCtorCall JavaCode
newObjMixedArgs VSType JavaCode
ot [SValue JavaCode]
vs NamedArgs JavaCode
ns = VSType JavaCode
-> (VSType JavaCode -> SValue JavaCode) -> SValue JavaCode
forall (r :: * -> *).
UnRepr r TypeData =>
VSType r -> (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod VSType JavaCode
ot (\VSType JavaCode
t ->
    MixedCall JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
String -> MixedCtorCall r
G.newObjMixedArgs (String
new String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ") VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns)
  extNewObjMixedArgs :: MixedCall JavaCode
extNewObjMixedArgs String
l VSType JavaCode
ot [SValue JavaCode]
vs NamedArgs JavaCode
ns = do
    JavaCode TypeData
t <- VSType JavaCode
ot
    Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    let tp :: String
tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString JavaCode TypeData
t
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
l String
tp) Map QualifiedName [ExceptionType]
mem))
    MixedCtorCall JavaCode
forall (r :: * -> *). OOValueExpression r => MixedCtorCall r
newObjMixedArgs (JavaCode TypeData -> VSType JavaCode
forall a s. a -> State s a
toState JavaCode TypeData
t) [SValue JavaCode]
vs NamedArgs JavaCode
ns
  libNewObjMixedArgs :: MixedCall JavaCode
libNewObjMixedArgs = MixedCall JavaCode
forall (r :: * -> *). OORenderSym 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 ()
-> VS (JavaCode ValData) -> VS (JavaCode ValData)
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
>> VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSType r -> Doc -> SValue r
mkStateVal
    (String -> VSType JavaCode
forall (r :: * -> *). OOTypeSym r => String -> VSType r
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 = VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSType r -> Doc -> SValue r
mkStateVal VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void (String -> Doc
jSystem (String
jStdOut String -> String -> String
`access` String
printLabel))
  printLnFunc :: SValue JavaCode
printLnFunc = VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSType r -> Doc -> SValue r
mkStateVal VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void (String -> Doc
jSystem (String
jStdOut String -> String -> String
`access` String
jPrintLn))
  printFileFunc :: SValue JavaCode -> SValue JavaCode
printFileFunc = (JavaCode TypeData -> JavaCode ValData -> VS (JavaCode ValData))
-> VSType JavaCode
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
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 :: * -> *).
CommonRenderSym r =>
r TypeData -> Doc -> SValue r
mkVal JavaCode TypeData
v (Doc -> VS (JavaCode ValData))
-> (JavaCode ValData -> Doc)
-> JavaCode ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
printLabel (Doc -> Doc)
-> (JavaCode ValData -> Doc) -> JavaCode ValData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    JavaCode ValData -> Doc
JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value) VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void
  printFileLnFunc :: SValue JavaCode -> SValue JavaCode
printFileLnFunc = (JavaCode TypeData -> JavaCode ValData -> VS (JavaCode ValData))
-> VSType JavaCode
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
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 :: * -> *).
CommonRenderSym r =>
r TypeData -> Doc -> SValue r
mkVal JavaCode TypeData
v (Doc -> VS (JavaCode ValData))
-> (JavaCode ValData -> Doc)
-> JavaCode ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
jPrintLn (Doc -> Doc)
-> (JavaCode ValData -> Doc) -> JavaCode ValData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    JavaCode ValData -> Doc
JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value) VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void

  cast :: VSType JavaCode -> SValue JavaCode -> SValue JavaCode
cast = VSType JavaCode -> SValue JavaCode -> SValue JavaCode
jCast

  call :: Maybe String -> Maybe Doc -> MixedCall JavaCode
call = String -> Maybe String -> Maybe Doc -> MixedCall JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String -> Maybe String -> Maybe Doc -> MixedCall r
CP.call' String
jName

  valFromData :: Maybe Int
-> Maybe Integer -> VSType JavaCode -> Doc -> SValue JavaCode
valFromData Maybe Int
p Maybe Integer
i VSType JavaCode
t' Doc
d = do
    JavaCode TypeData
t <- VSType JavaCode
t'
    JavaCode ValData -> VS (JavaCode ValData)
forall a s. a -> State s a
toState (JavaCode ValData -> VS (JavaCode ValData))
-> JavaCode ValData -> VS (JavaCode ValData)
forall a b. (a -> b) -> a -> b
$ (TypeData -> Doc -> ValData)
-> JavaCode TypeData -> JavaCode Doc -> JavaCode ValData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues (Maybe Int -> Maybe Integer -> TypeData -> Doc -> ValData
vd Maybe Int
p Maybe Integer
i) JavaCode TypeData
t (Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)

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

instance InternalValueExp JavaCode where
  objMethodCallMixedArgs' :: String
-> VSType JavaCode
-> SValue JavaCode
-> [SValue JavaCode]
-> NamedArgs JavaCode
-> SValue JavaCode
objMethodCallMixedArgs' String
f VSType JavaCode
t SValue JavaCode
o [SValue JavaCode]
ps NamedArgs JavaCode
ns = do
    JavaCode ValData
ob <- VS (JavaCode ValData)
SValue JavaCode
o
    Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    let tp :: String
tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString (JavaCode (Value JavaCode) -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType JavaCode ValData
JavaCode (Value JavaCode)
ob)
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
tp String
f) Map QualifiedName [ExceptionType]
mem))
    String
-> VSType JavaCode
-> SValue JavaCode
-> [SValue JavaCode]
-> NamedArgs JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String
-> VSType r -> SValue r -> [SValue r] -> NamedArgs r -> SValue r
G.objMethodCall String
f VSType JavaCode
t SValue JavaCode
o [SValue JavaCode]
ps NamedArgs JavaCode
ns
  classMethodCallMixedArgs' :: String -> VSType JavaCode -> MixedCtorCall JavaCode
classMethodCallMixedArgs' String
f VSType JavaCode
t VSType JavaCode
c [SValue JavaCode]
ps NamedArgs JavaCode
ns = do
    JavaCode TypeData
cls <- VSType JavaCode
c
    Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    let tp :: String
tp = JavaCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString JavaCode TypeData
cls
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
tp String
f) Map QualifiedName [ExceptionType]
mem))
    String -> VSType JavaCode -> MixedCtorCall JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
String
-> VSType r -> VSType r -> [SValue r] -> NamedArgs r -> SValue r
CG.classMethodCall String
f VSType JavaCode
t VSType JavaCode
c [SValue JavaCode]
ps NamedArgs JavaCode
ns

instance FunctionSym JavaCode where
  type Function JavaCode = FuncData

instance OOFunctionSym JavaCode where
  func :: String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
func = String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
G.func
  objAccess :: SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
objAccess = SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SValue r -> VSFunction r -> SValue r
G.objAccess

instance GetSet JavaCode where
  get :: SValue JavaCode -> SVariable JavaCode -> SValue JavaCode
get = SValue JavaCode -> SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym 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 :: * -> *).
OORenderSym 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 Array JavaCode where
  arrayElem :: SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
arrayElem = SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData) =>
SValue r -> SVariable 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 -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VSType r -> SVariable r
var String
"length" VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
int)
  arrayCopy :: SValue JavaCode -> SValue JavaCode
arrayCopy SValue JavaCode
arr = let
    arrTp :: VSType JavaCode
arrTp = (JavaCode ValData -> JavaCode TypeData)
-> VS (JavaCode ValData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode ValData -> JavaCode TypeData
JavaCode (Value JavaCode) -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType VS (JavaCode ValData)
SValue JavaCode
arr
    in VSType JavaCode
-> SValue JavaCode
-> String
-> [SValue JavaCode]
-> SValue JavaCode
forall (r :: * -> *).
InternalValueExp r =>
VSType r -> SValue r -> String -> [SValue r] -> SValue r
objMethodCall VSType JavaCode
arrTp SValue JavaCode
arr String
"clone" []

instance List JavaCode where
  listSize :: SValue JavaCode -> SValue JavaCode
listSize = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). OORenderSym r => SValue r -> SValue r
C.listSize
  listAdd :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
listAdd = SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
SValue r -> SValue r -> SValue r -> SValue r
G.listAdd
  listAppend :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
listAppend = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
SValue r -> SValue r -> SValue r
G.listAppend
  listAccess :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
listAccess = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SValue r -> SValue r
G.listAccess
  listSet :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
listSet = SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SValue r -> SValue r -> SValue r -> SValue r
G.listSet
  indexOf :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
indexOf = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SValue r -> SValue r -> SValue r
CP.indexOf String
jIndex

instance Set JavaCode where
  contains :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
contains = String -> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym 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 :: * -> *).
OORenderSym 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 :: * -> *).
OORenderSym 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 :: * -> *).
OORenderSym r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
jListUnion

instance InternalList JavaCode where
  listSlice' :: Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MSBlock JavaCode
listSlice' = Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> Maybe (SValue JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> MSBlock JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Maybe (SValue r)
-> Maybe (SValue r)
-> Maybe (SValue r)
-> SVariable r
-> SValue r
-> MSBlock r
M.listSlice

instance InternalGetSet JavaCode where
  getFunc :: SVariable JavaCode -> VSFunction JavaCode
getFunc = SVariable JavaCode -> VSFunction JavaCode
forall (r :: * -> *). OORenderSym r => SVariable r -> VSFunction r
G.getFunc
  setFunc :: VSType JavaCode
-> SVariable JavaCode -> SValue JavaCode -> VSFunction JavaCode
setFunc = VSType JavaCode
-> SVariable JavaCode -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
OORenderSym r =>
VSType r -> SVariable r -> SValue r -> VSFunction r
G.setFunc

instance InternalListFunc JavaCode where
  listSizeFunc :: SValue JavaCode -> VSFunction JavaCode
listSizeFunc SValue JavaCode
_ = VSFunction JavaCode
forall (r :: * -> *). OORenderSym r => VSFunction r
CP.listSizeFunc
  listAddFunc :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
listAddFunc SValue JavaCode
_ = String -> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SValue r -> SValue r -> VSFunction r
CP.listAddFunc String
jListAdd
  listAppendFunc :: SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
listAppendFunc SValue JavaCode
_ = String -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SValue r -> VSFunction r
G.listAppendFunc String
jListAdd
  listAccessFunc :: VSType JavaCode -> SValue JavaCode -> VSFunction JavaCode
listAccessFunc = String -> VSType JavaCode -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData) =>
String -> VSType r -> SValue r -> VSFunction r
CP.listAccessFunc' String
jListAccess
  listSetFunc :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
listSetFunc = SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
jListSetFunc

instance BinderSym JavaCode where
  binder :: String -> VSType JavaCode -> VSBinder JavaCode
binder String
nm VSType JavaCode
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)
-> VSType JavaCode -> VSBinder JavaCode
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VSType JavaCode
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 ThunkSym JavaCode where
  type Thunk JavaCode = CommonThunk VS

instance ThunkAssign JavaCode where
  thunkAssign :: SVariable JavaCode -> VSThunk JavaCode -> MSStatement JavaCode
thunkAssign SVariable JavaCode
v VSThunk JavaCode
t = do
    String
iName <- MS String
genLoopIndex
    let
      i :: SVariable JavaCode
i = String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
String -> VSType r -> SVariable r
var String
iName VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
int
      dim :: VS (JavaCode ValData)
dim = (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b. (a -> b) -> a -> b
$ StateT
  ValueState
  Identity
  (JavaCode (CommonThunk (StateT ValueState Identity)))
VSThunk JavaCode
t StateT
  ValueState
  Identity
  (JavaCode (CommonThunk (StateT ValueState Identity)))
-> (JavaCode (CommonThunk (StateT ValueState Identity))
    -> StateT ValueState Identity ValData)
-> StateT ValueState Identity ValData
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
>>= (StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData)
-> CommonThunk (StateT ValueState Identity)
-> StateT ValueState Identity ValData
forall (s :: * -> *).
(s ValData -> s ValData) -> CommonThunk s -> s ValData
commonThunkDim ((JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (JavaCode ValData) -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). List r => SValue r -> SValue r
listSize (VS (JavaCode ValData) -> VS (JavaCode ValData))
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure) (CommonThunk (StateT ValueState Identity)
 -> StateT ValueState Identity ValData)
-> (JavaCode (CommonThunk (StateT ValueState Identity))
    -> CommonThunk (StateT ValueState Identity))
-> JavaCode (CommonThunk (StateT ValueState Identity))
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
forall a. JavaCode a -> a
unJC
      loopInit :: MSStatement JavaCode
loopInit = LensLike'
  (Zoomed
     (StateT ValueState Identity)
     (CommonThunk (StateT ValueState Identity)))
  MethodState
  ValueState
-> StateT
     ValueState Identity (CommonThunk (StateT ValueState Identity))
-> StateT
     MethodState Identity (CommonThunk (StateT ValueState 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)
     (CommonThunk (StateT ValueState Identity)))
  MethodState
  ValueState
(ValueState
 -> Focusing
      Identity (CommonThunk (StateT ValueState Identity)) ValueState)
-> MethodState
-> Focusing
     Identity (CommonThunk (StateT ValueState Identity)) MethodState
Lens' MethodState ValueState
lensMStoVS ((JavaCode (CommonThunk (StateT ValueState Identity))
 -> CommonThunk (StateT ValueState Identity))
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
-> StateT
     ValueState Identity (CommonThunk (StateT ValueState Identity))
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode (CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
forall a. JavaCode a -> a
unJC StateT
  ValueState
  Identity
  (JavaCode (CommonThunk (StateT ValueState Identity)))
VSThunk JavaCode
t) StateT
  MethodState Identity (CommonThunk (StateT ValueState Identity))
-> (CommonThunk (StateT ValueState Identity)
    -> MSStatement JavaCode)
-> MSStatement JavaCode
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
>>= (CommonThunk (StateT ValueState Identity) -> MSStatement JavaCode)
-> (CommonThunk (StateT ValueState Identity)
    -> MSStatement JavaCode)
-> CommonThunk (StateT ValueState Identity)
-> MSStatement JavaCode
forall (s :: * -> *) a.
(CommonThunk s -> a) -> (CommonThunk s -> a) -> CommonThunk s -> a
commonThunkElim
        (MSStatement JavaCode
-> CommonThunk (StateT ValueState Identity) -> MSStatement JavaCode
forall a b. a -> b -> a
const MSStatement JavaCode
forall (r :: * -> *). StatementSym r => MSStatement r
emptyStmt) (MSStatement JavaCode
-> CommonThunk (StateT ValueState Identity) -> MSStatement JavaCode
forall a b. a -> b -> a
const (MSStatement JavaCode
 -> CommonThunk (StateT ValueState Identity)
 -> MSStatement JavaCode)
-> MSStatement JavaCode
-> CommonThunk (StateT ValueState Identity)
-> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable JavaCode
v (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ VSType JavaCode -> SValue JavaCode
forall (r :: * -> *).
(Literal r, UnRepr r TypeData) =>
VSType r -> SValue r
litZero (VSType JavaCode -> SValue JavaCode)
-> VSType JavaCode -> SValue JavaCode
forall a b. (a -> b) -> a -> b
$ (JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
v)
      loopBody :: MSStatement JavaCode
loopBody = LensLike'
  (Zoomed
     (StateT ValueState Identity)
     (CommonThunk (StateT ValueState Identity)))
  MethodState
  ValueState
-> StateT
     ValueState Identity (CommonThunk (StateT ValueState Identity))
-> StateT
     MethodState Identity (CommonThunk (StateT ValueState 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)
     (CommonThunk (StateT ValueState Identity)))
  MethodState
  ValueState
(ValueState
 -> Focusing
      Identity (CommonThunk (StateT ValueState Identity)) ValueState)
-> MethodState
-> Focusing
     Identity (CommonThunk (StateT ValueState Identity)) MethodState
Lens' MethodState ValueState
lensMStoVS ((JavaCode (CommonThunk (StateT ValueState Identity))
 -> CommonThunk (StateT ValueState Identity))
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
-> StateT
     ValueState Identity (CommonThunk (StateT ValueState Identity))
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode (CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
forall a. JavaCode a -> a
unJC StateT
  ValueState
  Identity
  (JavaCode (CommonThunk (StateT ValueState Identity)))
VSThunk JavaCode
t) StateT
  MethodState Identity (CommonThunk (StateT ValueState Identity))
-> (CommonThunk (StateT ValueState Identity)
    -> MSStatement JavaCode)
-> MSStatement JavaCode
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
>>= (CommonThunk (StateT ValueState Identity) -> MSStatement JavaCode)
-> (CommonThunk (StateT ValueState Identity)
    -> MSStatement JavaCode)
-> CommonThunk (StateT ValueState Identity)
-> MSStatement JavaCode
forall (s :: * -> *) a.
(CommonThunk s -> a) -> (CommonThunk s -> a) -> CommonThunk s -> a
commonThunkElim
        (SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue JavaCode -> MSStatement JavaCode)
-> (CommonThunk (StateT ValueState Identity) -> SValue JavaCode)
-> CommonThunk (StateT ValueState Identity)
-> MSStatement JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
List r =>
SValue r -> SValue r -> SValue r -> SValue r
listSet (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v) (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
i) (VS (JavaCode ValData) -> SValue JavaCode)
-> (CommonThunk (StateT ValueState Identity)
    -> VS (JavaCode ValData))
-> CommonThunk (StateT ValueState Identity)
-> SValue JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SValue JavaCode -> VSThunk JavaCode -> SValue JavaCode
forall (r :: * -> *).
VectorExpression r =>
SValue r -> VSThunk r -> SValue r
vecIndex (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
i) (StateT
   ValueState
   Identity
   (JavaCode (CommonThunk (StateT ValueState Identity)))
 -> VS (JavaCode ValData))
-> (CommonThunk (StateT ValueState Identity)
    -> StateT
         ValueState
         Identity
         (JavaCode (CommonThunk (StateT ValueState Identity))))
-> CommonThunk (StateT ValueState Identity)
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (CommonThunk (StateT ValueState Identity))
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JavaCode (CommonThunk (StateT ValueState Identity))
 -> StateT
      ValueState
      Identity
      (JavaCode (CommonThunk (StateT ValueState Identity))))
-> (CommonThunk (StateT ValueState Identity)
    -> JavaCode (CommonThunk (StateT ValueState Identity)))
-> CommonThunk (StateT ValueState Identity)
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CommonThunk (StateT ValueState Identity)
-> JavaCode (CommonThunk (StateT ValueState Identity))
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
        ((SVariable JavaCode
v &+=) (VS (JavaCode ValData) -> MSStatement JavaCode)
-> (CommonThunk (StateT ValueState Identity)
    -> VS (JavaCode ValData))
-> CommonThunk (StateT ValueState Identity)
-> MSStatement JavaCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SValue JavaCode -> VSThunk JavaCode -> SValue JavaCode
forall (r :: * -> *).
VectorExpression r =>
SValue r -> VSThunk r -> SValue r
vecIndex (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
i) (StateT
   ValueState
   Identity
   (JavaCode (CommonThunk (StateT ValueState Identity)))
 -> VS (JavaCode ValData))
-> (CommonThunk (StateT ValueState Identity)
    -> StateT
         ValueState
         Identity
         (JavaCode (CommonThunk (StateT ValueState Identity))))
-> CommonThunk (StateT ValueState Identity)
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (CommonThunk (StateT ValueState Identity))
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JavaCode (CommonThunk (StateT ValueState Identity))
 -> StateT
      ValueState
      Identity
      (JavaCode (CommonThunk (StateT ValueState Identity))))
-> (CommonThunk (StateT ValueState Identity)
    -> JavaCode (CommonThunk (StateT ValueState Identity)))
-> CommonThunk (StateT ValueState Identity)
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CommonThunk (StateT ValueState Identity)
-> JavaCode (CommonThunk (StateT ValueState Identity))
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
    [MSStatement JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
StatementSym r =>
[MSStatement r] -> MSStatement r
multi [MSStatement JavaCode
loopInit,
      SVariable JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SVariable r
-> SValue r -> SValue r -> SValue r -> MSBody r -> MSStatement r
forRange SVariable JavaCode
i (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
0) VS (JavaCode ValData)
SValue JavaCode
dim (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
1) (MSBody JavaCode -> MSStatement JavaCode)
-> MSBody JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ [MSBlock JavaCode] -> MSBody JavaCode
forall (r :: * -> *). BodySym r => [MSBlock r] -> MSBody r
body [[MSStatement JavaCode] -> MSBlock JavaCode
forall (r :: * -> *). BlockSym r => [MSStatement r] -> MSBlock r
block [MSStatement JavaCode
loopBody]]]

instance VectorType JavaCode where
  vecType :: VSType JavaCode -> VSType JavaCode
vecType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType

instance VectorDecl JavaCode where
  vecDec :: Integer
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
vecDec = Integer
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
Integer -> SVariable r -> r ScopeData -> MSStatement r
listDec
  vecDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
vecDecDef = SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> [SValue r] -> MSStatement r
listDecDef

instance VectorThunk JavaCode where
  vecThunk :: SVariable JavaCode -> VSThunk JavaCode
vecThunk = JavaCode (CommonThunk (StateT ValueState Identity))
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JavaCode (CommonThunk (StateT ValueState Identity))
 -> StateT
      ValueState
      Identity
      (JavaCode (CommonThunk (StateT ValueState Identity))))
-> (State ValueState (JavaCode VarData)
    -> JavaCode (CommonThunk (StateT ValueState Identity)))
-> State ValueState (JavaCode VarData)
-> StateT
     ValueState
     Identity
     (JavaCode (CommonThunk (StateT ValueState Identity)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CommonThunk (StateT ValueState Identity)
-> JavaCode (CommonThunk (StateT ValueState Identity))
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (CommonThunk (StateT ValueState Identity)
 -> JavaCode (CommonThunk (StateT ValueState Identity)))
-> (State ValueState (JavaCode VarData)
    -> CommonThunk (StateT ValueState Identity))
-> State ValueState (JavaCode VarData)
-> JavaCode (CommonThunk (StateT ValueState Identity))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StateT ValueState Identity ValData
-> CommonThunk (StateT ValueState Identity)
forall (s :: * -> *). s ValData -> CommonThunk s
pureValue (StateT ValueState Identity ValData
 -> CommonThunk (StateT ValueState Identity))
-> (State ValueState (JavaCode VarData)
    -> StateT ValueState Identity ValData)
-> State ValueState (JavaCode VarData)
-> CommonThunk (StateT ValueState Identity)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> (State ValueState (JavaCode VarData) -> VS (JavaCode ValData))
-> State ValueState (JavaCode VarData)
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State ValueState (JavaCode VarData) -> VS (JavaCode ValData)
SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf

instance VectorExpression JavaCode where
  vecScale :: SValue JavaCode -> VSThunk JavaCode -> VSThunk JavaCode
vecScale SValue JavaCode
k = (JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode -> VSThunk JavaCode
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
 -> VSThunk JavaCode -> VSThunk JavaCode)
-> (JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode
-> VSThunk JavaCode
forall a b. (a -> b) -> a -> b
$ (Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode)
forall a b. (a -> b) -> JavaCode a -> JavaCode b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Thunk JavaCode -> Thunk JavaCode)
 -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> (Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
forall a b. (a -> b) -> a -> b
$ (StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall (s :: * -> *).
(s ValData -> s ValData) -> CommonThunk s -> CommonThunk s
vectorize ((JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SValue JavaCode
k #*) (VS (JavaCode ValData) -> VS (JavaCode ValData))
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure)
  vecAdd :: VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode
vecAdd = (JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode
forall a b c.
(a -> b -> c)
-> StateT ValueState Identity a
-> StateT ValueState Identity b
-> StateT ValueState Identity c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((JavaCode (Thunk JavaCode)
  -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
 -> VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode)
-> (JavaCode (Thunk JavaCode)
    -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode
-> VSThunk JavaCode
-> VSThunk JavaCode
forall a b. (a -> b) -> a -> b
$ (Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
forall a b c.
(a -> b -> c) -> JavaCode a -> JavaCode b -> JavaCode c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
 -> JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode))
-> (Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
forall a b. (a -> b) -> a -> b
$ (StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall (s :: * -> *).
(s ValData -> s ValData -> s ValData)
-> CommonThunk s -> CommonThunk s -> CommonThunk s
vectorize2 (\StateT ValueState Identity ValData
v1 StateT ValueState Identity ValData
v2 -> (JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b. (a -> b) -> a -> b
$ (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT ValueState Identity ValData
v1 SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
NumericExpression r =>
SValue r -> SValue r -> SValue r
#+ (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT ValueState Identity ValData
v2)
  vecIndex :: SValue JavaCode -> VSThunk JavaCode -> SValue JavaCode
vecIndex SValue JavaCode
i = (VSThunk JavaCode
-> (JavaCode (Thunk JavaCode) -> 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
>>= (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> (JavaCode (CommonThunk (StateT ValueState Identity))
    -> StateT ValueState Identity ValData)
-> JavaCode (CommonThunk (StateT ValueState Identity))
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData)
-> CommonThunk (StateT ValueState Identity)
-> StateT ValueState Identity ValData
forall (s :: * -> *).
(s ValData -> s ValData) -> CommonThunk s -> s ValData
commonVecIndex ((JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (VS (JavaCode ValData)
 -> VS (JavaCode ValData) -> VS (JavaCode ValData))
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
forall a b c. (a -> b -> c) -> b -> a -> c
flip VS (JavaCode ValData)
-> VS (JavaCode ValData) -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). List r => SValue r -> SValue r -> SValue r
listAccess VS (JavaCode ValData)
SValue JavaCode
i (VS (JavaCode ValData) -> VS (JavaCode ValData))
-> (StateT ValueState Identity ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure) (CommonThunk (StateT ValueState Identity)
 -> StateT ValueState Identity ValData)
-> (JavaCode (CommonThunk (StateT ValueState Identity))
    -> CommonThunk (StateT ValueState Identity))
-> JavaCode (CommonThunk (StateT ValueState Identity))
-> StateT ValueState Identity ValData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode (CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
forall a. JavaCode a -> a
unJC)
  vecDot :: VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode
vecDot = (JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode
forall a b c.
(a -> b -> c)
-> StateT ValueState Identity a
-> StateT ValueState Identity b
-> StateT ValueState Identity c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((JavaCode (Thunk JavaCode)
  -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
 -> VSThunk JavaCode -> VSThunk JavaCode -> VSThunk JavaCode)
-> (JavaCode (Thunk JavaCode)
    -> JavaCode (Thunk JavaCode) -> JavaCode (Thunk JavaCode))
-> VSThunk JavaCode
-> VSThunk JavaCode
-> VSThunk JavaCode
forall a b. (a -> b) -> a -> b
$ (Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
forall a b c.
(a -> b -> c) -> JavaCode a -> JavaCode b -> JavaCode c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
 -> JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode)
 -> JavaCode (Thunk JavaCode))
-> (Thunk JavaCode -> Thunk JavaCode -> Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
-> JavaCode (Thunk JavaCode)
forall a b. (a -> b) -> a -> b
$ (CommonThunk (StateT ValueState Identity)
 -> CommonThunk (StateT ValueState Identity))
-> (CommonThunk (StateT ValueState Identity)
    -> CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall a b.
(a -> b)
-> (CommonThunk (StateT ValueState Identity) -> a)
-> CommonThunk (StateT ValueState Identity)
-> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall (s :: * -> *). CommonThunk s -> CommonThunk s
sumComponents ((CommonThunk (StateT ValueState Identity)
  -> CommonThunk (StateT ValueState Identity))
 -> CommonThunk (StateT ValueState Identity)
 -> CommonThunk (StateT ValueState Identity))
-> (CommonThunk (StateT ValueState Identity)
    -> CommonThunk (StateT ValueState Identity)
    -> CommonThunk (StateT ValueState Identity))
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> (StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData
 -> StateT ValueState Identity ValData)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
-> CommonThunk (StateT ValueState Identity)
forall (s :: * -> *).
(s ValData -> s ValData -> s ValData)
-> CommonThunk s -> CommonThunk s -> CommonThunk s
vectorize2 (\StateT ValueState Identity ValData
v1 StateT ValueState Identity ValData
v2 -> (JavaCode ValData -> ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JavaCode ValData -> ValData
forall a. JavaCode a -> a
unJC (VS (JavaCode ValData) -> StateT ValueState Identity ValData)
-> VS (JavaCode ValData) -> StateT ValueState Identity ValData
forall a b. (a -> b) -> a -> b
$ (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT ValueState Identity ValData
v1 SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
NumericExpression r =>
SValue r -> SValue r -> SValue r
#* (ValData -> JavaCode ValData)
-> StateT ValueState Identity ValData -> VS (JavaCode ValData)
forall a b.
(a -> b)
-> StateT ValueState Identity a -> StateT ValueState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ValData -> JavaCode ValData
forall a. a -> JavaCode a
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT ValueState Identity ValData
v2)

instance RenderFunction JavaCode where
  funcFromData :: Doc -> VSType JavaCode -> VSFunction JavaCode
funcFromData Doc
d = (JavaCode TypeData -> JavaCode FuncData)
-> VSType JavaCode -> State ValueState (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 (Function JavaCode) -> 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 (Function JavaCode) -> 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 where
  multiAssign :: [SVariable JavaCode] -> [SValue JavaCode] -> MSStatement JavaCode
multiAssign [SVariable JavaCode]
_ [SValue JavaCode]
_ = String -> MSStatement JavaCode
forall a. HasCallStack => String -> a
error (String -> MSStatement JavaCode) -> String -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiAssignError String
jName

instance InternalIOStmt JavaCode where
  printSt :: Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
printSt Bool
_ Maybe (SValue JavaCode)
_ = SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SValue r -> SValue r -> MSStatement r
CP.printSt

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

instance RenderStatement JavaCode where
  stmt :: MSStatement JavaCode -> MSStatement JavaCode
stmt = MSStatement JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
MSStatement r -> MSStatement r
G.stmt
  loopStmt :: MSStatement JavaCode -> MSStatement JavaCode
loopStmt = MSStatement JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
MSStatement r -> MSStatement r
G.loopStmt
  stmtFromData :: Doc -> Terminator -> MSStatement JavaCode
stmtFromData Doc
d Terminator
t = JavaCode (Statement JavaCode) -> MSStatement JavaCode
forall a s. a -> State s a
toState (JavaCode (Statement JavaCode) -> MSStatement JavaCode)
-> JavaCode (Statement JavaCode) -> MSStatement JavaCode
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 where
  statement :: JavaCode (Statement JavaCode) -> 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 (Statement JavaCode) -> 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 StatementSym JavaCode where
  -- Terminator determines how statements end
  type Statement JavaCode = (Doc, Terminator)
  valStmt :: SValue JavaCode -> MSStatement JavaCode
valStmt = Terminator -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Terminator -> SValue r -> MSStatement r
G.valStmt Terminator
Semi
  emptyStmt :: MSStatement JavaCode
emptyStmt = MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => MSStatement r
G.emptyStmt
  multi :: [MSStatement JavaCode] -> MSStatement JavaCode
multi = ([JavaCode (Doc, Terminator)] -> JavaCode (Doc, Terminator))
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> StateT MethodState Identity (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 AssignStatement JavaCode where
  assign :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
assign = Terminator
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
G.assign Terminator
Semi
  &-= :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
(&-=) = Terminator
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
G.subAssign Terminator
Semi
  &+= :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
(&+=) = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r -> SValue r -> MSStatement r
C.increment
  &++ :: SVariable JavaCode -> MSStatement JavaCode
(&++) = SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r -> MSStatement r
C.increment1
  &-- :: SVariable JavaCode -> MSStatement JavaCode
(&--) = SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r -> MSStatement r
C.decrement1

instance DeclStatement JavaCode where
  varDec :: SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
varDec = JavaCode (Attachment JavaCode)
-> JavaCode (Attachment JavaCode)
-> Doc
-> SVariable JavaCode
-> JavaCode ScopeData
-> MSStatement JavaCode
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData) =>
r (Attachment r)
-> r (Attachment r)
-> Doc
-> SVariable r
-> r ScopeData
-> MSStatement r
C.varDec JavaCode (Attachment JavaCode)
forall (r :: * -> *). AttachmentSym r => r (Attachment r)
classLevel JavaCode (Attachment JavaCode)
forall (r :: * -> *). AttachmentSym r => r (Attachment r)
instanceLevel Doc
empty
  varDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
varDecDef = Terminator
-> SVariable JavaCode
-> JavaCode ScopeData
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Terminator
-> SVariable r -> r ScopeData -> SValue r -> MSStatement r
C.varDecDef Terminator
Semi
  setDec :: SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
setDec = SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> MSStatement r
varDec
  setDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
setDecDef = SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> SValue r -> MSStatement r
varDecDef
  listDec :: Integer
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
listDec Integer
n SVariable JavaCode
v JavaCode ScopeData
scp = LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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 VarData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode VarData) ValueState)
-> MethodState -> Focusing Identity (JavaCode VarData) MethodState
Lens' MethodState ValueState
lensMStoVS State ValueState (JavaCode VarData)
SVariable JavaCode
v StateT MethodState Identity (JavaCode VarData)
-> (JavaCode VarData
    -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> StateT MethodState Identity (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 VarData
v' -> (JavaCode (Value JavaCode) -> Doc)
-> SValue JavaCode
-> SVariable JavaCode
-> JavaCode ScopeData
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(r (Value r) -> Doc)
-> SValue r -> SVariable r -> r ScopeData -> MSStatement r
C.listDec (JavaCode (Variable JavaCode) -> JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
r (Variable r) -> r (Value r) -> Doc
renderListDec JavaCode VarData
JavaCode (Variable JavaCode)
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] -> MSStatement JavaCode
listDecDef = SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r -> r ScopeData -> [SValue r] -> MSStatement r
CP.listDecDef
  arrayDec :: Integer
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
arrayDec Integer
n = SValue JavaCode
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SVariable r -> r ScopeData -> MSStatement r
CP.arrayDec (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n)
  arrayDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
arrayDecDef = SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r -> r ScopeData -> [SValue r] -> MSStatement r
CP.arrayDecDef
  constDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
constDecDef = SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
jConstDecDef
  funcDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MSBody JavaCode
-> MSStatement JavaCode
funcDecDef = SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MSBody JavaCode
-> MSStatement JavaCode
jFuncDecDef

instance OODeclStatement JavaCode where
  objDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
objDecDef = SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> SValue r -> MSStatement r
varDecDef
  objDecNew :: SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
objDecNew = SVariable JavaCode
-> JavaCode ScopeData -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
OORenderSym r =>
SVariable r -> r ScopeData -> [SValue r] -> MSStatement r
G.objDecNew
  extObjDecNew :: String
-> SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MSStatement JavaCode
extObjDecNew = String
-> SVariable JavaCode
-> JavaCode ScopeData
-> [SValue JavaCode]
-> MSStatement JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SVariable r -> r ScopeData -> [SValue r] -> MSStatement r
C.extObjDecNew

instance IOStatement JavaCode where
  print :: SValue JavaCode -> MSStatement JavaCode
print      = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
False Maybe (VS (JavaCode ValData))
Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc
  printLn :: SValue JavaCode -> MSStatement JavaCode
printLn    = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
True  Maybe (VS (JavaCode ValData))
Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc
  printStr :: String -> MSStatement JavaCode
printStr   = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
False Maybe (VS (JavaCode ValData))
Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc   (SValue JavaCode
 -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> StateT MethodState Identity (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 -> MSStatement JavaCode
printStrLn = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
True  Maybe (VS (JavaCode ValData))
Maybe (SValue JavaCode)
forall a. Maybe a
Nothing SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc (SValue JavaCode
 -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> (String -> SValue JavaCode)
-> String
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

  printFile :: SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
printFile SValue JavaCode
f      = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
False (VS (JavaCode ValData) -> Maybe (VS (JavaCode ValData))
forall a. a -> Maybe a
Just VS (JavaCode ValData)
SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue JavaCode
f)
  printFileLn :: SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
printFileLn SValue JavaCode
f    = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
True  (VS (JavaCode ValData) -> Maybe (VS (JavaCode ValData))
forall a. a -> Maybe a
Just VS (JavaCode ValData)
SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue JavaCode
f)
  printFileStr :: SValue JavaCode -> String -> MSStatement JavaCode
printFileStr SValue JavaCode
f   = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
False (VS (JavaCode ValData) -> Maybe (VS (JavaCode ValData))
forall a. a -> Maybe a
Just VS (JavaCode ValData)
SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue JavaCode
f)   (VS (JavaCode ValData)
 -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> (String -> VS (JavaCode ValData))
-> String
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (JavaCode ValData)
String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printFileStrLn :: SValue JavaCode -> String -> MSStatement JavaCode
printFileStrLn SValue JavaCode
f = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
True  (VS (JavaCode ValData) -> Maybe (VS (JavaCode ValData))
forall a. a -> Maybe a
Just VS (JavaCode ValData)
SValue JavaCode
f) (SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue JavaCode
f) (VS (JavaCode ValData)
 -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> (String -> VS (JavaCode ValData))
-> String
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (JavaCode ValData)
String -> SValue JavaCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

  getInput :: SVariable JavaCode -> MSStatement JavaCode
getInput SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
v SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  discardInput :: MSStatement JavaCode
discardInput = SValue JavaCode -> MSStatement JavaCode
jDiscardInput SValue JavaCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  getFileInput :: SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
getFileInput SValue JavaCode
f SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
v SValue JavaCode
f
  discardFileInput :: SValue JavaCode -> MSStatement JavaCode
discardFileInput = SValue JavaCode -> MSStatement JavaCode
jDiscardInput

  openFileR :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
openFileR = (SValue JavaCode -> VSType JavaCode -> SValue JavaCode)
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(SValue r -> VSType r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileR SValue JavaCode -> VSType JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
SValue r -> VSType r -> SValue r
jOpenFileR
  openFileW :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
openFileW = (SValue JavaCode
 -> VSType JavaCode -> SValue JavaCode -> SValue JavaCode)
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(SValue r -> VSType r -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileW SValue JavaCode
-> VSType JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA
  openFileA :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
openFileA = (SValue JavaCode
 -> VSType JavaCode -> SValue JavaCode -> SValue JavaCode)
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(SValue r -> VSType r -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileA SValue JavaCode
-> VSType JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
OORenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA
  closeFile :: SValue JavaCode -> MSStatement JavaCode
closeFile = String -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SValue r -> MSStatement r
G.closeFile String
jClose

  getFileInputLine :: SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
getFileInputLine SValue JavaCode
f SVariable JavaCode
v = SVariable JavaCode
v SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= SValue JavaCode
f SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
  discardFileLine :: SValue JavaCode -> MSStatement JavaCode
discardFileLine = String -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SValue r -> MSStatement r
CP.discardFileLine String
jNextLine
  getFileInputAll :: SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
getFileInputAll SValue JavaCode
f SVariable JavaCode
v = SValue JavaCode -> MSBody JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSBody r -> MSStatement r
while (SValue JavaCode
f SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jHasNextLineFunc)
    (MSStatement JavaCode -> MSBody JavaCode
forall (r :: * -> *). BodySym r => MSStatement r -> MSBody r
oneLiner (MSStatement JavaCode -> MSBody JavaCode)
-> MSStatement JavaCode -> MSBody JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). List r => SValue r -> SValue r -> SValue r
listAppend (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v) (SValue JavaCode
f SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc))

instance StringStatement JavaCode where
  stringSplit :: Char
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
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)
    Doc
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 (VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
string [SValue JavaCode
s SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. Char -> VSFunction JavaCode
forall (r :: * -> *). OORenderSym r => Char -> VSFunction r
jSplitFunc Char
d])
    Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt Doc
ss

  stringListVals :: [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
stringListVals = [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
[SVariable r] -> SValue r -> MSStatement r
M.stringListVals
  stringListLists :: [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
stringListLists = [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
[SVariable r] -> SValue r -> MSStatement r
M.stringListLists

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

instance OOFuncAppStatement JavaCode where
  selfInOutCall :: InOutCall JavaCode
selfInOutCall = (String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). OOValueExpression r => PosCall r
selfFuncApp

instance CommentStatement JavaCode where
  comment :: String -> MSStatement JavaCode
comment = Doc -> String -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Doc -> String -> MSStatement r
G.comment Doc
commentStart

instance ControlStatement JavaCode where
  break :: MSStatement JavaCode
break = Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt Doc
R.break
  continue :: MSStatement JavaCode
continue = Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt Doc
R.continue

  returnStmt :: SValue JavaCode -> MSStatement JavaCode
returnStmt = Terminator -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Terminator -> SValue r -> MSStatement r
G.returnStmt Terminator
Semi

  throw :: String -> MSStatement JavaCode
throw = (JavaCode (Value JavaCode) -> Doc)
-> Terminator -> String -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(r (Value r) -> Doc) -> Terminator -> String -> MSStatement r
G.throw JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). CommonRenderSym r => r (Value r) -> Doc
jThrowDoc Terminator
Semi

  ifCond :: [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode -> MSStatement JavaCode
ifCond = (Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
G.ifCond Doc -> Doc
parens Doc
bodyStart OptionalSpace
G.defaultOptSpace Doc
elseIfLabel Doc
bodyEnd Doc
empty
  switch :: SValue JavaCode
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
switch  = (Doc -> Doc)
-> MSStatement JavaCode
-> SValue JavaCode
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(Doc -> Doc)
-> MSStatement r
-> SValue r
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
C.switch Doc -> Doc
parens MSStatement JavaCode
forall (r :: * -> *). ControlStatement r => MSStatement r
break

  ifExists :: SValue JavaCode
-> MSBody JavaCode -> MSBody JavaCode -> MSStatement JavaCode
ifExists = SValue JavaCode
-> MSBody JavaCode -> MSBody JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SValue r -> MSBody r -> MSBody r -> MSStatement r
M.ifExists

  for :: MSStatement JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
for = Doc
-> Doc
-> MSStatement JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
Doc
-> Doc
-> MSStatement r
-> SValue r
-> MSStatement r
-> MSBody r
-> MSStatement r
C.for Doc
bodyStart Doc
bodyEnd
  forRange :: SVariable JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forRange = SVariable JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
SVariable r
-> SValue r -> SValue r -> SValue r -> MSBody r -> MSStatement r
M.forRange
  forEach :: SVariable JavaCode
-> SValue JavaCode -> MSBody JavaCode -> MSStatement JavaCode
forEach = Doc
-> Doc
-> Doc
-> Doc
-> SVariable JavaCode
-> SValue JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MSBody r
-> MSStatement r
CP.forEach Doc
bodyStart Doc
bodyEnd Doc
forLabel Doc
colon
  while :: SValue JavaCode -> MSBody JavaCode -> MSStatement JavaCode
while = (Doc -> Doc)
-> Doc
-> Doc
-> SValue JavaCode
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(Doc -> Doc) -> Doc -> Doc -> SValue r -> MSBody r -> MSStatement r
C.while Doc -> Doc
parens Doc
bodyStart Doc
bodyEnd

  tryCatch :: MSBody JavaCode -> MSBody JavaCode -> MSStatement JavaCode
tryCatch = (JavaCode (Body JavaCode) -> JavaCode (Body JavaCode) -> Doc)
-> MSBody JavaCode -> MSBody JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(r (Body r) -> r (Body r) -> Doc)
-> MSBody r -> MSBody r -> MSStatement r
G.tryCatch JavaCode (Body JavaCode) -> JavaCode (Body JavaCode) -> Doc
forall (r :: * -> *).
CommonRenderSym r =>
r (Body r) -> r (Body r) -> Doc
jTryCatch

  assert :: SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
assert SValue JavaCode
condition SValue JavaCode
errorMessage = do
    JavaCode ValData
cond <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode ValData))
  MethodState
  ValueState
-> VS (JavaCode ValData)
-> StateT MethodState Identity (JavaCode ValData)
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 ValData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode ValData) ValueState)
-> MethodState -> Focusing Identity (JavaCode ValData) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JavaCode ValData)
SValue JavaCode
condition
    JavaCode ValData
errMsg <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode ValData))
  MethodState
  ValueState
-> VS (JavaCode ValData)
-> StateT MethodState Identity (JavaCode ValData)
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 ValData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode ValData) ValueState)
-> MethodState -> Focusing Identity (JavaCode ValData) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JavaCode ValData)
SValue JavaCode
errorMessage
    Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt (JavaCode (Value JavaCode) -> JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *).
CommonRenderSym r =>
r (Value r) -> r (Value r) -> Doc
jAssert JavaCode ValData
JavaCode (Value JavaCode)
cond JavaCode ValData
JavaCode (Value JavaCode)
errMsg)

instance ObserverPattern JavaCode where
  notifyObservers :: VSFunction JavaCode -> VSType JavaCode -> MSStatement JavaCode
notifyObservers = VSFunction JavaCode -> VSType JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
OORenderSym r =>
VSFunction r -> VSType r -> MSStatement r
M.notifyObservers

instance StrategyPattern JavaCode where
  runStrategy :: String
-> [(String, MSBody JavaCode)]
-> Maybe (SValue JavaCode)
-> Maybe (SVariable JavaCode)
-> MSBlock JavaCode
runStrategy = String
-> [(String, MSBody JavaCode)]
-> Maybe (SValue JavaCode)
-> Maybe (SVariable JavaCode)
-> State MethodState (JavaCode Doc)
String
-> [(String, MSBody JavaCode)]
-> Maybe (SValue JavaCode)
-> Maybe (SVariable JavaCode)
-> MSBlock JavaCode
forall (r :: * -> *).
(CommonRenderSym r, Monad r) =>
String
-> [(String, MSBody r)]
-> Maybe (SValue r)
-> Maybe (SVariable r)
-> MS (r Doc)
M.runStrategy

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

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

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

instance MethodTypeSym JavaCode where
  type MethodType JavaCode = TypeData
  mType :: VSType JavaCode -> MSMthdType JavaCode
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode TypeData))
  MethodState
  ValueState
-> VSType JavaCode
-> StateT MethodState Identity (JavaCode TypeData)
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 -> StateT MethodState Identity (JavaCode TypeData)
String -> MSMthdType JavaCode
forall (r :: * -> *). Monad r => String -> MS (r TypeData)
G.construct

instance ParameterSym JavaCode where
  type Parameter JavaCode = ParamData
  param :: SVariable JavaCode -> MSParameter JavaCode
param = (JavaCode (Variable JavaCode) -> Doc)
-> SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
(r (Variable r) -> Doc) -> SVariable r -> MSParameter r
G.param JavaCode (Variable JavaCode) -> Doc
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData) =>
r (Variable r) -> Doc
renderParam
  pointerParam :: SVariable JavaCode -> MSParameter JavaCode
pointerParam = SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param

instance RenderParam JavaCode where
  paramFromData :: SVariable JavaCode -> Doc -> MSParameter JavaCode
paramFromData SVariable JavaCode
v' Doc
d = do
    JavaCode VarData
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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 VarData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode VarData) ValueState)
-> MethodState -> Focusing Identity (JavaCode VarData) MethodState
Lens' MethodState ValueState
lensMStoVS State ValueState (JavaCode VarData)
SVariable JavaCode
v'
    JavaCode ParamData -> State MethodState (JavaCode ParamData)
forall a s. a -> State s a
toState (JavaCode ParamData -> State MethodState (JavaCode ParamData))
-> JavaCode ParamData -> State MethodState (JavaCode ParamData)
forall a b. (a -> b) -> a -> b
$ (VarData -> Doc -> ParamData)
-> JavaCode VarData -> JavaCode Doc -> JavaCode ParamData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues VarData -> Doc -> ParamData
pd JavaCode VarData
v (Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)

instance ParamElim JavaCode where
  parameterName :: JavaCode (Parameter JavaCode) -> String
parameterName = JavaCode VarData -> String
JavaCode (Variable JavaCode) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName (JavaCode VarData -> String)
-> (JavaCode ParamData -> JavaCode VarData)
-> JavaCode ParamData
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> VarData) -> JavaCode ParamData -> JavaCode VarData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> VarData
paramVar
  parameterType :: JavaCode (Parameter JavaCode) -> JavaCode TypeData
parameterType = JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType (JavaCode VarData -> JavaCode TypeData)
-> (JavaCode ParamData -> JavaCode VarData)
-> JavaCode ParamData
-> JavaCode TypeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> VarData) -> JavaCode ParamData -> JavaCode VarData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> VarData
paramVar
  parameter :: JavaCode (Parameter JavaCode) -> 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 where
  type Method JavaCode = MethodData
  docMain :: MSBody JavaCode -> SMethod JavaCode
docMain = MSBody JavaCode -> SMethod JavaCode
forall (r :: * -> *). OORenderSym r => MSBody r -> SMethod r
CP.docMain
  function :: String
-> JavaCode (Visibility JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
function = String
-> JavaCode (Visibility JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> r (Visibility r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
G.function
  mainFunction :: MSBody JavaCode -> SMethod JavaCode
mainFunction = VSType JavaCode -> String -> MSBody JavaCode -> SMethod JavaCode
forall (r :: * -> *).
(OORenderSym r, UnRepr r TypeData, Monad r) =>
VSType r -> String -> MSBody r -> SMethod r
CP.mainFunction VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
string String
mainFunc
  docFunc :: String
-> [String] -> Maybe String -> SMethod JavaCode -> SMethod JavaCode
docFunc = String
-> [String] -> Maybe String -> SMethod JavaCode -> SMethod JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
String -> [String] -> Maybe String -> SMethod r -> SMethod r
CP.doxFunc

  inOutFunc :: String -> JavaCode (Visibility JavaCode) -> InOutFunc JavaCode
inOutFunc String
n JavaCode (Visibility JavaCode)
s = (VSType JavaCode
 -> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode)
-> InOutFunc JavaCode
jInOut (String
-> JavaCode (Visibility JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
MethodSym r =>
String
-> r (Visibility r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
function String
n JavaCode (Visibility JavaCode)
s)
  docInOutFunc :: String -> JavaCode (Visibility JavaCode) -> DocInOutFunc JavaCode
docInOutFunc String
n JavaCode (Visibility JavaCode)
s = InOutFunc JavaCode -> DocInOutFunc JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
jDocInOut (String -> JavaCode (Visibility JavaCode) -> InOutFunc JavaCode
forall (r :: * -> *).
MethodSym r =>
String -> r (Visibility r) -> InOutFunc r
inOutFunc String
n JavaCode (Visibility JavaCode)
s)

instance OOMethodSym JavaCode where
  method :: String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
method = String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> r (Visibility r)
-> r (Attachment r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
G.method
  getMethod :: SVariable JavaCode -> SMethod JavaCode
getMethod = SVariable JavaCode -> SMethod JavaCode
forall (r :: * -> *). OORenderSym r => SVariable r -> SMethod r
G.getMethod
  setMethod :: SVariable JavaCode -> SMethod JavaCode
setMethod = SVariable JavaCode -> SMethod JavaCode
forall (r :: * -> *). OORenderSym r => SVariable r -> SMethod r
G.setMethod
  constructor :: [MSParameter JavaCode]
-> NamedArgs JavaCode -> MSBody JavaCode -> SMethod JavaCode
constructor [MSParameter JavaCode]
ps NamedArgs JavaCode
is MSBody JavaCode
b = MS String
getClassName MS String
-> (String -> StateT MethodState Identity (JavaCode MethodData))
-> StateT MethodState Identity (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
-> [MSParameter JavaCode]
-> NamedArgs JavaCode
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> [MSParameter r] -> Initializers r -> MSBody r -> SMethod r
CP.constructor String
n [MSParameter JavaCode]
ps NamedArgs JavaCode
is MSBody JavaCode
b)

  inOutMethod :: String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> InOutFunc JavaCode
inOutMethod String
n JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p = (VSType JavaCode
 -> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode)
-> InOutFunc JavaCode
jInOut (String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
OOMethodSym r =>
String
-> r (Visibility r)
-> r (Attachment r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
method String
n JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p)
  docInOutMethod :: String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> DocInOutFunc JavaCode
docInOutMethod String
n JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p = InOutFunc JavaCode -> DocInOutFunc JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
jDocInOut (String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> InOutFunc JavaCode
forall (r :: * -> *).
OOMethodSym r =>
String -> r (Visibility r) -> r (Attachment r) -> InOutFunc r
inOutMethod String
n JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p)

instance RenderMethod JavaCode where
  commentedFunc :: State MethodState (JavaCode Doc)
-> SMethod JavaCode -> SMethod JavaCode
commentedFunc State MethodState (JavaCode Doc)
cmt SMethod JavaCode
m = (JavaCode MethodData
 -> JavaCode (Doc -> Doc) -> JavaCode MethodData)
-> StateT MethodState Identity (JavaCode MethodData)
-> State MethodState (JavaCode (Doc -> Doc))
-> StateT MethodState Identity (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) StateT MethodState Identity (JavaCode MethodData)
SMethod JavaCode
m
    ((JavaCode Doc -> JavaCode (Doc -> Doc))
-> State MethodState (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) State MethodState (JavaCode Doc)
cmt)

  mthdFromData :: VisibilityTag -> Doc -> SMethod JavaCode
mthdFromData VisibilityTag
_ Doc
d = JavaCode (Method JavaCode) -> SMethod JavaCode
forall a s. a -> State s a
toState (JavaCode (Method JavaCode) -> SMethod JavaCode)
-> JavaCode (Method JavaCode) -> SMethod JavaCode
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
$ Doc -> MethodData
mthd Doc
d

instance OORenderMethod JavaCode where
  intMethod :: Bool
-> String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
intMethod Bool
m String
n JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p MSMthdType JavaCode
t [MSParameter JavaCode]
ps MSBody JavaCode
b = do
    JavaCode TypeData
tp <- StateT MethodState Identity (JavaCode TypeData)
MSMthdType JavaCode
t
    [JavaCode ParamData]
pms <- [State MethodState (JavaCode ParamData)]
-> StateT MethodState Identity [JavaCode ParamData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [State MethodState (JavaCode ParamData)]
[MSParameter JavaCode]
ps
    JavaCode Doc
bd <- State MethodState (JavaCode Doc)
MSBody JavaCode
b
    Map QualifiedName [ExceptionType]
mem <- LensLike'
  (Zoomed
     (StateT ValueState Identity) (Map QualifiedName [ExceptionType]))
  MethodState
  ValueState
-> VS (Map QualifiedName [ExceptionType])
-> StateT MethodState Identity (Map QualifiedName [ExceptionType])
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) (Map QualifiedName [ExceptionType]))
  MethodState
  ValueState
(ValueState
 -> Focusing
      Identity (Map QualifiedName [ExceptionType]) ValueState)
-> MethodState
-> Focusing
     Identity (Map QualifiedName [ExceptionType]) MethodState
Lens' MethodState ValueState
lensMStoVS VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    [ExceptionType]
es <- MS [ExceptionType]
getExceptions
    String
mn <- LensLike'
  (Zoomed (StateT FileState Identity) String) MethodState FileState
-> StateT FileState Identity String -> MS String
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) MethodState FileState
-> StateT FileState 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 FileState Identity) String) MethodState FileState
(FileState -> Focusing Identity String FileState)
-> MethodState -> Focusing Identity String MethodState
Lens' MethodState FileState
lensMStoFS StateT FileState Identity String
getModuleName
    let excs :: [Exception]
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)
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((if Bool
m then MethodState -> MethodState
setCurrMain else MethodState -> MethodState
forall a. a -> a
id) (MethodState -> MethodState)
-> (MethodState -> MethodState) -> MethodState -> MethodState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Exception] -> MethodState -> MethodState
addExceptionImports [Exception]
excs)
    JavaCode MethodData
-> StateT MethodState Identity (JavaCode MethodData)
forall a. a -> StateT MethodState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (JavaCode MethodData
 -> StateT MethodState Identity (JavaCode MethodData))
-> JavaCode MethodData
-> StateT MethodState Identity (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
$ Doc -> MethodData
mthd (Doc -> MethodData) -> Doc -> MethodData
forall a b. (a -> b) -> a -> b
$ String
-> [String]
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> JavaCode TypeData
-> [JavaCode (Parameter JavaCode)]
-> JavaCode (Body JavaCode)
-> Doc
jMethod String
n ((Exception -> String) -> [Exception] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Exception -> String
exc [Exception]
excs) JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p JavaCode TypeData
tp [JavaCode ParamData]
[JavaCode (Parameter JavaCode)]
pms JavaCode Doc
JavaCode (Body JavaCode)
bd
  intFunc :: Bool
-> String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
intFunc = Bool
-> String
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
OORenderSym r =>
Bool
-> String
-> r (Visibility r)
-> r (Attachment r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
C.intFunc
  destructor :: [CSStateVar JavaCode] -> SMethod JavaCode
destructor [CSStateVar JavaCode]
_ = String -> SMethod JavaCode
forall a. HasCallStack => String -> a
error (String -> SMethod JavaCode) -> String -> SMethod JavaCode
forall a b. (a -> b) -> a -> b
$ String -> String
CP.destructorError String
jName

instance MethodElim JavaCode where
  method :: JavaCode (Method JavaCode) -> 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 where
  type StateVar JavaCode = Doc
  stateVar :: JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> CSStateVar JavaCode
stateVar = JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> CS (JavaCode Doc)
JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> CSStateVar JavaCode
forall (r :: * -> *).
(OORenderSym r, Monad r) =>
r (Visibility r) -> r (Attachment r) -> SVariable r -> CS (r Doc)
CP.stateVar
  stateVarDef :: JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode
stateVarDef = JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CS (JavaCode Doc)
JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode
forall (r :: * -> *).
(OORenderSym r, Monad r) =>
r (Visibility r)
-> r (Attachment r) -> SVariable r -> SValue r -> CS (r Doc)
CP.stateVarDef
  constVar :: JavaCode (Visibility JavaCode)
-> SVariable JavaCode -> SValue JavaCode -> CSStateVar JavaCode
constVar = Doc
-> JavaCode (Visibility JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CS (JavaCode Doc)
forall (r :: * -> *).
(CommonRenderSym r, Monad r) =>
Doc -> r (Visibility r) -> SVariable r -> SValue r -> CS (r Doc)
CP.constVar (JavaCode (Attachment JavaCode) -> Doc
forall (r :: * -> *). PermElim r => r (Attachment r) -> Doc
RC.perm (JavaCode (Attachment JavaCode)
forall (r :: * -> *). AttachmentSym r => r (Attachment r)
classLevel :: JavaCode (Attachment JavaCode)))

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

instance ClassSym JavaCode where
  type Class JavaCode = Doc
  buildClass :: Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
buildClass = Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
forall (r :: * -> *).
OORenderSym r =>
Maybe String
-> [CSStateVar r] -> [SMethod r] -> [SMethod r] -> SClass r
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
extraClass = String
-> Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> Maybe String
-> [CSStateVar r]
-> [SMethod r]
-> [SMethod r]
-> SClass r
jExtraClass
  implementingClass :: String
-> [String]
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
implementingClass = String
-> [String]
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> [String]
-> [CSStateVar r]
-> [SMethod r]
-> [SMethod r]
-> SClass r
G.implementingClass

  docClass :: String -> SClass JavaCode -> SClass JavaCode
docClass = String -> SClass JavaCode -> SClass JavaCode
forall (r :: * -> *).
OORenderSym r =>
String -> SClass r -> SClass r
CP.doxClass

instance RenderClass JavaCode where
  intClass :: String
-> JavaCode (Visibility JavaCode)
-> JavaCode Doc
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
intClass = (String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> JavaCode (Visibility JavaCode)
-> JavaCode Doc
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> [SMethod JavaCode]
-> CS (JavaCode Doc)
forall (r :: * -> *).
(OORenderSym r, Monad r) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r (Visibility r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> [SMethod r]
-> 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) -> (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 :: CS (JavaCode Doc) -> SClass JavaCode -> SClass JavaCode
commentedClass = CS (JavaCode Doc) -> SClass JavaCode -> CS (JavaCode Doc)
CS (JavaCode Doc) -> SClass JavaCode -> SClass JavaCode
forall (r :: * -> *).
(OORenderSym r, Monad r) =>
CS (r Doc) -> SClass r -> CS (r Doc)
G.commentedClass

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

instance ModuleSym JavaCode where
  type Module JavaCode = ModData
  buildModule :: String
-> [String]
-> [SMethod JavaCode]
-> [SClass JavaCode]
-> FSModule JavaCode
buildModule String
n = String
-> (String -> JavaCode (Import JavaCode))
-> [String]
-> [SMethod JavaCode]
-> [SClass JavaCode]
-> FSModule JavaCode
forall (r :: * -> *).
OORenderSym r =>
String
-> (String -> r (Import r))
-> [String]
-> [SMethod r]
-> [SClass r]
-> FSModule r
CP.buildModule' String
n String -> JavaCode (Import JavaCode)
forall (r :: * -> *). ImportSym r => String -> r (Import r)
langImport

instance RenderMod JavaCode where
  modFromData :: String -> FS Doc -> FSModule JavaCode
modFromData String
n = String
-> (Doc -> JavaCode (Module JavaCode))
-> FS Doc
-> FSModule JavaCode
forall (r :: * -> *).
String -> (Doc -> r (Module r)) -> FS Doc -> FSModule r
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 (Module JavaCode) -> JavaCode (Module JavaCode)
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 where
  module' :: JavaCode (Module JavaCode) -> 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) => VSType r
jBoolType :: forall (r :: * -> *). Monad r => VSType r
jBoolType = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Boolean String
jBool (String -> Doc
text String
jBool)

jInfileType :: (Monad r) => VSType r
jInfileType :: forall (r :: * -> *). Monad r => VSType r
jInfileType = do
  r TypeData
tpf <- CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
InFile String
jScanner Doc
jScanner'
  (ValueState -> ValueState) -> r TypeData -> VSType r
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
utilImport String
jScanner) r TypeData
tpf

jOutfileType :: (Monad r) => VSType r
jOutfileType :: forall (r :: * -> *). Monad r => VSType r
jOutfileType = do
  r TypeData
tpf <- CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
OutFile String
jPrintWriter (String -> Doc
text String
jPrintWriter)
  (ValueState -> ValueState) -> r TypeData -> VSType r
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
ioImport String
jPrintWriter) r TypeData
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 :: (UnRepr r TypeData, Monad r) => VSType r -> VSType r
jListType :: forall (r :: * -> *).
(UnRepr r TypeData, Monad r) =>
VSType r -> VSType r
jListType VSType r
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)
  VSType r
t VSType r -> (r TypeData -> VSType r) -> VSType r
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 -> VSType r
jListType' (CodeType -> VSType r)
-> (r TypeData -> CodeType) -> r TypeData -> VSType r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType)
  where jListType' :: CodeType -> VSType r
jListType' CodeType
Integer = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
List CodeType
Integer)
          String
lstInt (String -> Doc
text String
lstInt)
        jListType' CodeType
Float = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.listType String
arrayList VSType r
forall (r :: * -> *). Monad r => VSType r
CP.float
        jListType' CodeType
Double = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.listType String
arrayList VSType r
forall (r :: * -> *). Monad r => VSType r
CP.double
        jListType' CodeType
Boolean = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
List CodeType
Boolean) String
lstBool (String -> Doc
text String
lstBool)
        jListType' CodeType
_ = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.listType String
arrayList VSType r
t
        lstInt :: String
lstInt = String
arrayList String -> String -> String
`containing` String
jInteger
        lstBool :: String
lstBool = String
arrayList String -> String -> String
`containing` String
jBool'

jSetType :: (UnRepr r TypeData, Monad r) => VSType r -> VSType r
jSetType :: forall (r :: * -> *).
(UnRepr r TypeData, Monad r) =>
VSType r -> VSType r
jSetType VSType r
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")
  VSType r
t VSType r -> (r TypeData -> VSType r) -> VSType r
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 -> VSType r
jSetType' (CodeType -> VSType r)
-> (r TypeData -> CodeType) -> r TypeData -> VSType r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType)
  where jSetType' :: CodeType -> VSType r
jSetType' CodeType
Integer = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
Set CodeType
Integer)
          String
stInt (String -> Doc
text String
stInt)
        jSetType' CodeType
Float = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.setType String
"Set" VSType r
forall (r :: * -> *). Monad r => VSType r
CP.float
        jSetType' CodeType
Double = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.setType String
"Set" VSType r
forall (r :: * -> *). Monad r => VSType r
CP.double
        jSetType' CodeType
Boolean = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
Set CodeType
Boolean) String
stBool (String -> Doc
text String
stBool)
        jSetType' CodeType
_ = String -> VSType r -> VSType r
forall (r :: * -> *).
(Monad r, UnRepr r TypeData) =>
String -> VSType r -> VSType r
C.setType String
"Set" VSType r
t
        stInt :: String
stInt = String
"Set" String -> String -> String
`containing` String
jInteger
        stBool :: String
stBool = String
"Set" String -> String -> String
`containing` String
jBool'

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

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

jFileType :: (OORenderSym r) => VSType r
jFileType :: forall (r :: * -> *). OORenderSym r => VSType r
jFileType = do
  r TypeData
tpf <- String -> VSType r
forall (r :: * -> *). OOTypeSym r => String -> VSType r
obj String
jFile
  (ValueState -> ValueState) -> r TypeData -> VSType r
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
ioImport String
jFile) r TypeData
tpf

jFileWriterType :: (OORenderSym r) => VSType r
jFileWriterType :: forall (r :: * -> *). OORenderSym r => VSType r
jFileWriterType = do
  r TypeData
tpf <- String -> VSType r
forall (r :: * -> *). OOTypeSym r => String -> VSType r
obj String
jFileWriter
  (ValueState -> ValueState) -> r TypeData -> VSType r
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS (String -> ValueState -> ValueState)
-> String -> ValueState -> ValueState
forall a b. (a -> b) -> a -> b
$ String -> String
ioImport String
jFileWriter) r TypeData
tpf

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

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

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

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

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

jListSetFunc :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode ->
  VSFunction JavaCode
jListSetFunc :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
jListSetFunc SValue JavaCode
v SValue JavaCode
i SValue JavaCode
toVal = String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
func String
jListSet ((JavaCode ValData -> JavaCode TypeData)
-> VS (JavaCode ValData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode ValData -> JavaCode TypeData
JavaCode (Value JavaCode) -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType VS (JavaCode ValData)
SValue JavaCode
v) [SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
SValue r -> SValue r
intValue SValue JavaCode
i, SValue JavaCode
toVal]

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

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

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

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

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

jSplitFunc :: (OORenderSym r) => Char -> VSFunction r
jSplitFunc :: forall (r :: * -> *). OORenderSym r => Char -> VSFunction r
jSplitFunc Char
d = String
-> VSType r
-> [SValue r]
-> StateT ValueState Identity (r (Function r))
forall (r :: * -> *).
OOFunctionSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
func String
jSplit (VSType r -> VSType r
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType VSType r
forall (r :: * -> *). TypeSym r => VSType r
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 = VS (JavaCode ValData)
SValue JavaCode
v2 VS (JavaCode ValData)
-> (JavaCode ValData -> VS (JavaCode ValData))
-> VS (JavaCode ValData)
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 (JavaCode ValData)
CodeType -> SValue JavaCode
jEquality' (CodeType -> VS (JavaCode ValData))
-> (JavaCode ValData -> CodeType)
-> JavaCode ValData
-> VS (JavaCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType (JavaCode TypeData -> CodeType)
-> (JavaCode ValData -> JavaCode TypeData)
-> JavaCode ValData
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode ValData -> JavaCode TypeData
JavaCode (Value JavaCode) -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType
  where jEquality' :: CodeType -> SValue JavaCode
jEquality' CodeType
String = SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
objAccess SValue JavaCode
v1 (SValue JavaCode -> VSFunction JavaCode
jEqualsFunc SValue JavaCode
v2)
        jEquality' CodeType
_ = VSUnOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSUnOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool SValue JavaCode
v1 SValue JavaCode
v2

jLambda :: [r BinderD] -> r (Value r) -> Doc -- Needs (CommonRenderSym r) constraint
jLambda :: forall (r :: * -> *). [r BinderD] -> r (Value r) -> Doc
jLambda = String -> [r BinderD] -> r (Value r) -> 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 :: VSType JavaCode -> SValue JavaCode -> SValue JavaCode
jCast :: VSType JavaCode -> SValue JavaCode -> SValue JavaCode
jCast = StateT ValueState Identity (VS (JavaCode ValData))
-> VS (JavaCode ValData)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT ValueState Identity (VS (JavaCode ValData))
 -> VS (JavaCode ValData))
-> (VSType JavaCode
    -> VS (JavaCode ValData)
    -> StateT ValueState Identity (VS (JavaCode ValData)))
-> VSType JavaCode
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: (JavaCode TypeData -> JavaCode ValData -> VS (JavaCode ValData))
-> VSType JavaCode
-> VS (JavaCode ValData)
-> StateT ValueState Identity (VS (JavaCode ValData))
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\JavaCode TypeData
t JavaCode ValData
v -> CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode ValData
-> VS (JavaCode ValData)
jCast' (JavaCode TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType JavaCode TypeData
t) (JavaCode TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType (JavaCode TypeData -> CodeType) -> JavaCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$ JavaCode (Value JavaCode) -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType
  JavaCode ValData
JavaCode (Value JavaCode)
v) JavaCode TypeData
t JavaCode ValData
v)
  where jCast' :: CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode ValData
-> SValue JavaCode
jCast' CodeType
Double CodeType
String JavaCode TypeData
_ JavaCode ValData
v = SValue JavaCode -> SValue JavaCode
jParseDblFunc (JavaCode ValData -> VS (JavaCode ValData)
forall a s. a -> State s a
toState JavaCode ValData
v)
        jCast' CodeType
Float CodeType
String JavaCode TypeData
_ JavaCode ValData
v = SValue JavaCode -> SValue JavaCode
jParseFloatFunc (JavaCode ValData -> VS (JavaCode ValData)
forall a s. a -> State s a
toState JavaCode ValData
v)
        jCast' CodeType
_ CodeType
_ JavaCode TypeData
t JavaCode ValData
v = VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *).
CommonRenderSym r =>
VSType r -> Doc -> SValue r
mkStateVal (JavaCode TypeData -> VSType JavaCode
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 JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value JavaCode ValData
JavaCode (Value JavaCode)
v))

jConstDecDef :: SVariable JavaCode -> JavaCode ScopeData -> SValue JavaCode ->
  MSStatement JavaCode
jConstDecDef :: SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
jConstDecDef SVariable JavaCode
v' JavaCode ScopeData
scp SValue JavaCode
def' = do
  JavaCode VarData
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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 VarData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode VarData) ValueState)
-> MethodState -> Focusing Identity (JavaCode VarData) MethodState
Lens' MethodState ValueState
lensMStoVS State ValueState (JavaCode VarData)
SVariable JavaCode
v'
  JavaCode ValData
def <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode ValData))
  MethodState
  ValueState
-> VS (JavaCode ValData)
-> StateT MethodState Identity (JavaCode ValData)
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 ValData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode ValData) ValueState)
-> MethodState -> Focusing Identity (JavaCode ValData) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JavaCode ValData)
SValue JavaCode
def'
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> MethodState -> MethodState
useVarName (String -> MethodState -> MethodState)
-> String -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ JavaCode (Variable JavaCode) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName JavaCode VarData
JavaCode (Variable JavaCode)
v
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> ScopeData -> MethodState -> MethodState
setVarScope (JavaCode (Variable JavaCode) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName JavaCode VarData
JavaCode (Variable JavaCode)
v) (JavaCode ScopeData -> ScopeData
forall (r :: * -> *). ScopeElim r => r ScopeData -> ScopeData
scopeData JavaCode ScopeData
scp)
  Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement JavaCode) -> Doc -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ Doc
jFinal Doc -> Doc -> Doc
<+> JavaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType (JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType JavaCode VarData
JavaCode (Variable JavaCode)
v) Doc -> Doc -> Doc
<+>
    JavaCode (Variable JavaCode) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable JavaCode VarData
JavaCode (Variable JavaCode)
v Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+> JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value JavaCode ValData
JavaCode (Value JavaCode)
def

jFuncDecDef :: SVariable JavaCode -> JavaCode ScopeData ->
  [SVariable JavaCode] -> MSBody JavaCode -> MSStatement JavaCode
jFuncDecDef :: SVariable JavaCode
-> JavaCode ScopeData
-> [SVariable JavaCode]
-> MSBody JavaCode
-> MSStatement JavaCode
jFuncDecDef SVariable JavaCode
v JavaCode ScopeData
scp [SVariable JavaCode]
ps MSBody JavaCode
bod = do
  JavaCode VarData
vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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 VarData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode VarData) ValueState)
-> MethodState -> Focusing Identity (JavaCode VarData) MethodState
Lens' MethodState ValueState
lensMStoVS State ValueState (JavaCode VarData)
SVariable JavaCode
v
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> MethodState -> MethodState
useVarName (String -> MethodState -> MethodState)
-> String -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ JavaCode (Variable JavaCode) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName JavaCode VarData
JavaCode (Variable JavaCode)
vr
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> ScopeData -> MethodState -> MethodState
setVarScope (JavaCode (Variable JavaCode) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName JavaCode VarData
JavaCode (Variable JavaCode)
vr) (JavaCode ScopeData -> ScopeData
forall (r :: * -> *). ScopeElim r => r ScopeData -> ScopeData
scopeData JavaCode ScopeData
scp)
  [JavaCode VarData]
pms <- (State ValueState (JavaCode VarData)
 -> StateT MethodState Identity (JavaCode VarData))
-> [State ValueState (JavaCode VarData)]
-> StateT MethodState Identity [JavaCode VarData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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 VarData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JavaCode VarData) ValueState)
-> MethodState -> Focusing Identity (JavaCode VarData) MethodState
Lens' MethodState ValueState
lensMStoVS) [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
ps
  JavaCode Doc
b <- State MethodState (JavaCode Doc)
MSBody JavaCode
bod
  Doc -> MSStatement JavaCode
forall (r :: * -> *). CommonRenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement JavaCode) -> Doc -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ JavaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType (JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType JavaCode VarData
JavaCode (Variable JavaCode)
vr) Doc -> Doc -> Doc
<+> JavaCode (Variable JavaCode) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable JavaCode VarData
JavaCode (Variable JavaCode)
vr Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+>
    Doc -> Doc
parens ([JavaCode (Variable JavaCode)] -> Doc
forall (r :: * -> *). CommonRenderSym r => [r (Variable r)] -> Doc
variableList [JavaCode VarData]
[JavaCode (Variable JavaCode)]
pms) Doc -> Doc -> Doc
<+> Doc
jLambdaSep Doc -> Doc -> Doc
<+> Doc
bodyStart Doc -> Doc -> Doc
$$ Doc -> Doc
indent (JavaCode (Body JavaCode) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body JavaCode Doc
JavaCode (Body JavaCode)
b)
    Doc -> Doc -> Doc
$$ Doc
bodyEnd

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

jTryCatch :: (CommonRenderSym r) => r (Body r) -> r (Body r) -> Doc
jTryCatch :: forall (r :: * -> *).
CommonRenderSym r =>
r (Body r) -> r (Body r) -> Doc
jTryCatch r (Body r)
tb r (Body r)
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 (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
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 (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
cb,
  Doc
rbrace]

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

jOut :: (CommonRenderSym r, UnRepr r TypeData) => Bool -> Maybe (SValue r) ->
  SValue r -> SValue r -> MSStatement r
jOut :: forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
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 r)))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r (Value r)) ValueState)
-> MethodState -> Focusing Identity (r (Value r)) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
v StateT MethodState Identity (r (Value r))
-> (r (Value r) -> StateT MethodState Identity (r (Statement r)))
-> StateT MethodState Identity (r (Statement r))
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 (Statement r))
jOut' (CodeType -> StateT MethodState Identity (r (Statement r)))
-> (r (Value r) -> CodeType)
-> r (Value r)
-> StateT MethodState Identity (r (Statement r))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType (r TypeData -> CodeType)
-> (r (Value r) -> r TypeData) -> r (Value r) -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Value r) -> r TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r TypeData
valueType
  where jOut' :: CodeType -> StateT MethodState Identity (r (Statement r))
jOut' (List (Object String
_)) = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r (Statement r))
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
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 (Statement r))
forall (r :: * -> *).
InternalIOStmt r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
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 (Statement r))
forall (r :: * -> *).
InternalIOStmt r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
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" VSType r
forall (r :: * -> *). TypeSym r => VSType r
string [SValue r
v])
        jOut' CodeType
_ = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r (Statement r))
forall (r :: * -> *).
(CommonRenderSym r, UnRepr r TypeData) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v

jDiscardInput :: SValue JavaCode -> MSStatement JavaCode
jDiscardInput :: SValue JavaCode -> MSStatement JavaCode
jDiscardInput SValue JavaCode
inFn = SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextFunc

jInput :: SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput :: SVariable JavaCode -> SValue JavaCode -> SValue JavaCode
jInput SVariable JavaCode
vr SValue JavaCode
inFn = do
  JavaCode VarData
v <- State ValueState (JavaCode VarData)
SVariable JavaCode
vr
  let jInput' :: CodeType -> SValue JavaCode
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 -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
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 -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
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 -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' CodeType
Boolean = SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextBoolFunc
      jInput' CodeType
String = SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' CodeType
Char = (SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextFunc) SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jCharAtFunc
      jInput' CodeType
_ = String -> VS (JavaCode ValData)
forall a. HasCallStack => String -> a
error String
"Attempt to read value of unreadable type"
  CodeType -> SValue JavaCode
jInput' (JavaCode TypeData -> CodeType
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> CodeType
getCodeType (JavaCode TypeData -> CodeType) -> JavaCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$ JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType JavaCode VarData
JavaCode (Variable JavaCode)
v)

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

jOpenFileWorA :: (OORenderSym r) => SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA :: forall (r :: * -> *).
OORenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA SValue r
n VSType r
t SValue r
wa = PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VSType r
t [PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VSType r
forall (r :: * -> *). OORenderSym r => VSType r
jFileWriterType [PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VSType r
forall (r :: * -> *). OORenderSym r => VSType r
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 VarData -> JavaCode ValData -> Doc)
-> State ValueState (JavaCode VarData)
-> VS (JavaCode ValData)
-> StateT ValueState Identity Doc
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\JavaCode VarData
vnew JavaCode ValData
s -> JavaCode (Variable JavaCode) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable JavaCode VarData
JavaCode (Variable JavaCode)
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) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType JavaCode VarData
JavaCode (Variable JavaCode)
vnew) Doc -> Doc -> Doc
<> Doc -> Doc
parens (JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value JavaCode ValData
JavaCode (Value JavaCode)
s))

jMethod :: Label -> [String] -> JavaCode (Visibility JavaCode) ->
  JavaCode (Attachment JavaCode) -> JavaCode TypeData ->
  [JavaCode (Parameter JavaCode)] -> JavaCode (Body JavaCode) -> Doc
jMethod :: String
-> [String]
-> JavaCode (Visibility JavaCode)
-> JavaCode (Attachment JavaCode)
-> JavaCode TypeData
-> [JavaCode (Parameter JavaCode)]
-> JavaCode (Body JavaCode)
-> Doc
jMethod String
n [String]
es JavaCode (Visibility JavaCode)
s JavaCode (Attachment JavaCode)
p JavaCode TypeData
t [JavaCode (Parameter JavaCode)]
ps JavaCode (Body JavaCode)
b = [Doc] -> Doc
vcat [
  JavaCode (Visibility JavaCode) -> Doc
forall (r :: * -> *). VisibilityElim r => r (Visibility r) -> Doc
RC.visibility JavaCode (Visibility JavaCode)
s Doc -> Doc -> Doc
<+> JavaCode (Attachment JavaCode) -> Doc
forall (r :: * -> *). PermElim r => r (Attachment r) -> Doc
RC.perm JavaCode (Attachment JavaCode)
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 (Parameter JavaCode)] -> Doc
forall (r :: * -> *). CommonRenderSym r => [r (Parameter r)] -> Doc
parameterList [JavaCode (Parameter JavaCode)]
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 (Body JavaCode) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body JavaCode (Body JavaCode)
b,
  Doc
rbrace]

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

jAssignFromArray :: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray :: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray Integer
_ [] = []
jAssignFromArray Integer
c (SVariable JavaCode
v:[SVariable JavaCode]
vs) = (SVariable JavaCode
v SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= VSType JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderValue r =>
VSType r -> SValue r -> SValue r
cast ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
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 -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
Array r =>
SValue r -> SVariable r -> SVariable r
arrayElem (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
c) SVariable JavaCode
outputs)) StateT MethodState Identity (JavaCode (Doc, Terminator))
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray (Integer
cInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1) [SVariable JavaCode]
vs

jInOutCall :: (Label -> VSType JavaCode -> [SValue JavaCode] ->
  SValue JavaCode) -> Label -> [SValue JavaCode] -> [SVariable JavaCode] ->
  [SVariable JavaCode] -> MSStatement JavaCode
jInOutCall :: (String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [] [] = SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void [SValue JavaCode]
ins
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [SVariable JavaCode
out] [] = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable JavaCode
out (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
out)
  [SValue JavaCode]
ins
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [] [SVariable JavaCode
out] = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable JavaCode
out (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
out)
  (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
out VS (JavaCode ValData)
-> [VS (JavaCode ValData)] -> [VS (JavaCode ValData)]
forall a. a -> [a] -> [a]
: [VS (JavaCode ValData)]
[SValue JavaCode]
ins)
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n [SValue JavaCode]
ins [SVariable JavaCode]
outs [SVariable JavaCode]
both = [State ValueState (JavaCode VarData)] -> MSStatement JavaCode
fCall [State ValueState (JavaCode VarData)]
rets
  where rets :: [State ValueState (JavaCode VarData)]
rets = [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
both [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
forall a. [a] -> [a] -> [a]
++ [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
outs
        fCall :: [State ValueState (JavaCode VarData)] -> MSStatement JavaCode
fCall [State ValueState (JavaCode VarData)
x] = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign State ValueState (JavaCode VarData)
SVariable JavaCode
x (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
x)
          ((SVariable JavaCode -> VS (JavaCode ValData))
-> [SVariable JavaCode] -> [VS (JavaCode ValData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> VS (JavaCode ValData)
SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [SVariable JavaCode]
both [VS (JavaCode ValData)]
-> [VS (JavaCode ValData)] -> [VS (JavaCode ValData)]
forall a. [a] -> [a] -> [a]
++ [VS (JavaCode ValData)]
[SValue JavaCode]
ins)
        fCall [State ValueState (JavaCode VarData)]
xs = MS Bool
isOutputsDeclared MS Bool
-> (Bool
    -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> StateT MethodState Identity (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 ()
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> StateT MethodState Identity (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
>>
          [MSStatement JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
StatementSym r =>
[MSStatement r] -> MSStatement r
multi ((if Bool
odec then SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign else (SVariable JavaCode
-> JavaCode ScopeData -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> SValue r -> MSStatement r
`varDecDef` JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local)) SVariable JavaCode
outputs
          (String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n VSType JavaCode
jArrayType ((SVariable JavaCode -> VS (JavaCode ValData))
-> [SVariable JavaCode] -> [VS (JavaCode ValData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> VS (JavaCode ValData)
SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [SVariable JavaCode]
both [VS (JavaCode ValData)]
-> [VS (JavaCode ValData)] -> [VS (JavaCode ValData)]
forall a. [a] -> [a] -> [a]
++ [VS (JavaCode ValData)]
[SValue JavaCode]
ins)) StateT MethodState Identity (JavaCode (Doc, Terminator))
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray Integer
0 [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
xs))

jInOut :: (VSType JavaCode -> [MSParameter JavaCode] -> MSBody JavaCode ->
    SMethod JavaCode) ->
  [SVariable JavaCode] -> [SVariable JavaCode] -> [SVariable JavaCode] ->
  MSBody JavaCode -> SMethod JavaCode
jInOut :: (VSType JavaCode
 -> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode)
-> InOutFunc JavaCode
jInOut VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f [SVariable JavaCode]
ins [] [] MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void ((SVariable JavaCode -> State MethodState (JavaCode ParamData))
-> [SVariable JavaCode] -> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> State MethodState (JavaCode ParamData)
SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [SVariable JavaCode]
ins) MSBody JavaCode
b
jInOut VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f [SVariable JavaCode]
ins [SVariable JavaCode
v] [] MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
v) ((SVariable JavaCode -> State MethodState (JavaCode ParamData))
-> [SVariable JavaCode] -> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable JavaCode -> State MethodState (JavaCode ParamData)
SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [SVariable JavaCode]
ins)
  ((JavaCode (Doc, Terminator)
 -> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> State MethodState (JavaCode Doc)
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> State MethodState (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 -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> MSStatement r
varDec SVariable JavaCode
v JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local) State MethodState (JavaCode Doc)
MSBody JavaCode
b (SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$
  SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f [SVariable JavaCode]
ins [] [SVariable JavaCode
v] MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
v)
  ((State ValueState (JavaCode VarData) -> MSParameter JavaCode)
-> [State ValueState (JavaCode VarData)] -> [MSParameter JavaCode]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData) -> MSParameter JavaCode
SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param ([State ValueState (JavaCode VarData)] -> [MSParameter JavaCode])
-> [State ValueState (JavaCode VarData)] -> [MSParameter JavaCode]
forall a b. (a -> b) -> a -> b
$ State ValueState (JavaCode VarData)
SVariable JavaCode
v State ValueState (JavaCode VarData)
-> [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
forall a. a -> [a] -> [a]
: [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
ins) ((JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> State MethodState (JavaCode Doc)
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> State MethodState (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) State MethodState (JavaCode Doc)
MSBody JavaCode
b
  (SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f [SVariable JavaCode]
ins [SVariable JavaCode]
outs [SVariable JavaCode]
both MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ([State ValueState (JavaCode VarData)] -> VSType JavaCode
returnTp [State ValueState (JavaCode VarData)]
rets)
  ((State ValueState (JavaCode VarData) -> MSParameter JavaCode)
-> [State ValueState (JavaCode VarData)] -> [MSParameter JavaCode]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData) -> MSParameter JavaCode
SVariable JavaCode -> MSParameter JavaCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param ([State ValueState (JavaCode VarData)] -> [MSParameter JavaCode])
-> [State ValueState (JavaCode VarData)] -> [MSParameter JavaCode]
forall a b. (a -> b) -> a -> b
$ [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
both [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
forall a. [a] -> [a] -> [a]
++ [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
ins) ((JavaCode (Doc, Terminator)
 -> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> State MethodState (JavaCode Doc)
-> StateT MethodState Identity (JavaCode (Doc, Terminator))
-> State MethodState (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) StateT MethodState Identity (JavaCode (Doc, Terminator))
MSStatement JavaCode
decls
  State MethodState (JavaCode Doc)
MSBody JavaCode
b ([State ValueState (JavaCode VarData)] -> MSStatement JavaCode
returnSt [State ValueState (JavaCode VarData)]
rets))
  where returnTp :: [State ValueState (JavaCode VarData)] -> VSType JavaCode
returnTp [State ValueState (JavaCode VarData)
x] = (JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData) -> VSType JavaCode
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
JavaCode (Variable JavaCode) -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r TypeData
variableType State ValueState (JavaCode VarData)
x
        returnTp [State ValueState (JavaCode VarData)]
_ = VSType JavaCode
jArrayType
        returnSt :: [State ValueState (JavaCode VarData)] -> MSStatement JavaCode
returnSt [State ValueState (JavaCode VarData)
x] = SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> MSStatement JavaCode)
-> SValue JavaCode -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf State ValueState (JavaCode VarData)
SVariable JavaCode
x
        returnSt [State ValueState (JavaCode VarData)]
_ = [MSStatement JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
StatementSym r =>
[MSStatement r] -> MSStatement r
multi (Integer
-> SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
Integer -> SVariable r -> r ScopeData -> MSStatement r
arrayDec (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ [State ValueState (JavaCode VarData)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [State ValueState (JavaCode VarData)]
rets) SVariable JavaCode
outputs JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local
          StateT MethodState Identity (JavaCode (Doc, Terminator))
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SValue JavaCode] -> [MSStatement JavaCode]
assignArray Integer
0 ((State ValueState (JavaCode VarData) -> VS (JavaCode ValData))
-> [State ValueState (JavaCode VarData)] -> [VS (JavaCode ValData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData) -> VS (JavaCode ValData)
SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [State ValueState (JavaCode VarData)]
rets)
          [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a. [a] -> [a] -> [a]
++ [SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
outputs)])
        assignArray :: Integer -> [SValue JavaCode] -> [MSStatement JavaCode]
        assignArray :: Integer -> [SValue JavaCode] -> [MSStatement JavaCode]
assignArray Integer
_ [] = []
        assignArray Integer
c (SValue JavaCode
v:[SValue JavaCode]
vs) = (SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
Array r =>
SValue r -> SVariable r -> SVariable r
arrayElem (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
c) SVariable JavaCode
outputs SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= SValue JavaCode
v) StateT MethodState Identity (JavaCode (Doc, Terminator))
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SValue JavaCode] -> [MSStatement JavaCode]
assignArray (Integer
cInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1) [SValue JavaCode]
vs
        decls :: MSStatement JavaCode
decls = [MSStatement JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
StatementSym r =>
[MSStatement r] -> MSStatement r
multi ([MSStatement JavaCode] -> MSStatement JavaCode)
-> [MSStatement JavaCode] -> MSStatement JavaCode
forall a b. (a -> b) -> a -> b
$ (SVariable JavaCode
 -> StateT MethodState Identity (JavaCode (Doc, Terminator)))
-> [SVariable JavaCode]
-> [StateT MethodState Identity (JavaCode (Doc, Terminator))]
forall a b. (a -> b) -> [a] -> [b]
map (SVariable JavaCode -> JavaCode ScopeData -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> r ScopeData -> MSStatement r
`varDec` JavaCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local) [SVariable JavaCode]
outs
        rets :: [State ValueState (JavaCode VarData)]
rets = [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
both [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
-> [State ValueState (JavaCode VarData)]
forall a. [a] -> [a] -> [a]
++ [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
outs

jDocInOut :: (CommonRenderSym r) => ([SVariable r] -> [SVariable r] -> [SVariable r] ->
    MSBody r -> SMethod r) ->
  String -> [(String, SVariable r)] -> [(String, SVariable r)] ->
  [(String, SVariable r)] -> MSBody r -> SMethod r
jDocInOut :: forall (r :: * -> *).
CommonRenderSym r =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f String
desc [(String, SVariable r)]
is [] [] MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
CommonRenderSym r =>
FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
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] -> MSBody r -> SMethod r
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) [] [] MSBody r
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f String
desc [(String, SVariable r)]
is [(String, SVariable r)
o] [] MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
CommonRenderSym r =>
FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
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] -> MSBody r -> SMethod r
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] [] MSBody r
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f String
desc [(String, SVariable r)]
is [] [(String, SVariable r)
both] MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
CommonRenderSym r =>
FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
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] -> MSBody r -> SMethod r
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] MSBody r
b)
jDocInOut [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
CommonRenderSym r =>
FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
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] -> MSBody r -> SMethod r
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) MSBody r
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 :: (OORenderSym r) => Label -> Maybe Label ->
  [CSStateVar r] -> [SMethod r] -> [SMethod r] -> SClass r
jExtraClass :: forall (r :: * -> *).
OORenderSym r =>
String
-> Maybe String
-> [CSStateVar r]
-> [SMethod r]
-> [SMethod r]
-> SClass r
jExtraClass String
n = String
-> r (Visibility r)
-> r Doc
-> [CS (r (StateVar r))]
-> [MS (r (Method r))]
-> [MS (r (Method r))]
-> CS (r (Class r))
forall (r :: * -> *).
RenderClass r =>
String
-> r (Visibility r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> [SMethod r]
-> SClass r
intClass String
n (VisibilityTag -> Doc -> r (Visibility r)
forall (r :: * -> *).
RenderVisibility r =>
VisibilityTag -> Doc -> r (Visibility r)
visibilityFromData VisibilityTag
Priv Doc
empty) (r Doc
 -> [CS (r (StateVar r))]
 -> [MS (r (Method r))]
 -> [MS (r (Method r))]
 -> CS (r (Class r)))
-> (Maybe String -> r Doc)
-> Maybe String
-> [CS (r (StateVar r))]
-> [MS (r (Method r))]
-> [MS (r (Method r))]
-> CS (r (Class r))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> r Doc
forall (r :: * -> *). RenderClass r => Maybe String -> r Doc
inherit

addCallExcsCurrMod :: String -> VS ()
addCallExcsCurrMod :: String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n = do
  String
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
  Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
  (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
cm String
n) Map QualifiedName [ExceptionType]
mem))

addConstructorCallExcsCurrMod :: (UnRepr r TypeData) =>
  VSType r -> (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod :: forall (r :: * -> *).
UnRepr r TypeData =>
VSType r -> (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod VSType r
ot VSType r -> SValue r
f = do
  r TypeData
t <- VSType r
ot
  String
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
  Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
  let tp :: String
tp = r TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString r TypeData
t
  (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((ValueState -> ValueState)
-> ([ExceptionType] -> ValueState -> ValueState)
-> Maybe [ExceptionType]
-> ValueState
-> ValueState
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ValueState -> ValueState
forall a. a -> a
id [ExceptionType] -> ValueState -> ValueState
addExceptions (QualifiedName
-> Map QualifiedName [ExceptionType] -> Maybe [ExceptionType]
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (String -> String -> QualifiedName
qualName String
cm String
tp) Map QualifiedName [ExceptionType]
mem))
  VSType r -> SValue r
f (r TypeData -> VSType r
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure r TypeData
t)