{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PostfixOperators #-}

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

import Utils.Drasil (indent)

import GOOL.Drasil.CodeType (CodeType(..))
import GOOL.Drasil.ClassInterface (Label, MSBody, VSType, SVariable, SValue, 
  VSFunction, MSStatement, MSParameter, SMethod, CSStateVar, SClass, OOProg, 
  ProgramSym(..), FileSym(..), PermanenceSym(..), BodySym(..), oneLiner, 
  BlockSym(..), TypeSym(..), TypeElim(..), VariableSym(..), VariableElim(..), 
  ValueSym(..), Argument(..), Literal(..), MathConstant(..), VariableValue(..), 
  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..), 
  Comparison(..), ValueExpression(..), funcApp, selfFuncApp, extFuncApp, newObj,
  InternalValueExp(..), FunctionSym(..), ($.), GetSet(..), List(..), 
  InternalList(..), StatementSym(..), AssignStatement(..), 
  (&=), DeclStatement(..), IOStatement(..), StringStatement(..), 
  FuncAppStatement(..), CommentStatement(..), ControlStatement(..), 
  StatePattern(..), ObserverPattern(..), StrategyPattern(..), ScopeSym(..), 
  ParameterSym(..), MethodSym(..), StateVarSym(..), ClassSym(..), ModuleSym(..))
import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
  ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
  BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
  OpElim(uOpPrec, bOpPrec), RenderVariable(..), InternalVarElim(variableBind), 
  RenderValue(..), ValueElim(valuePrec),  InternalGetSet(..), 
  InternalListFunc(..), RenderFunction(..), FunctionElim(functionType), 
  InternalAssignStmt(..), InternalIOStmt(..), InternalControlStmt(..), 
  RenderStatement(..), StatementElim(statementTerm), RenderScope(..), 
  ScopeElim, MethodTypeSym(..), RenderParam(..), 
  ParamElim(parameterName, parameterType), RenderMethod(..), MethodElim, 
  StateVarElim, RenderClass(..), ClassElim, RenderMod(..), ModuleElim, 
  BlockCommentSym(..), BlockCommentElim)
import qualified GOOL.Drasil.RendererClasses as RC (import', perm, body, block,
  type', uOp, bOp, variable, value, function, statement, scope, parameter,
  method, stateVar, class', module', blockComment')
import GOOL.Drasil.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)
import qualified GOOL.Drasil.LanguageRenderer as R (sqrt, abs, log10, 
  log, exp, sin, cos, tan, asin, acos, atan, floor, ceil, pow, package, class', 
  multiStmt, body, printFile, param, listDec, classVar, cast, castObj, static, 
  dynamic, break, continue, private, public, blockCmt, docCmt, addComments, 
  commentedMod, commentedItem)
import GOOL.Drasil.LanguageRenderer.Constructors (mkStmt, mkStateVal, mkVal,
  VSOp, unOpPrec, powerPrec, unExpr, unExpr', unExprNumDbl, typeUnExpr, binExpr,
  binExprNumDbl', typeBinExpr)
import qualified GOOL.Drasil.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, staticVar, 
  objVar, 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, increment, objDecNew, print, closeFile, returnStmt, valStmt, 
  comment, throw, ifCond, tryCatch, construct, param, method, getMethod, 
  setMethod, function, buildClass, implementingClass, commentedClass, 
  modFromData, fileDoc, fileFromData)
import GOOL.Drasil.LanguageRenderer.LanguagePolymorphic (docFuncRepr)
import qualified GOOL.Drasil.LanguageRenderer.CommonPseudoOO as CP (int, 
  constructor, doxFunc, doxClass, doxMod, extVar, classVar, objVarSelf,
  extFuncAppMixedArgs, indexOf, listAddFunc, discardFileLine, intClass, 
  funcType, arrayType, pi, printSt, arrayDec, arrayDecDef, openFileA, forEach, 
  docMain, mainFunction, buildModule', bindingError, listDecDef, 
  destructorError, stateVarDef, constVar, litArray, call', listSizeFunc, 
  listAccessFunc', notNull, doubleRender, double, openFileR, openFileW, 
  stateVar, floatRender, float, string')
import qualified GOOL.Drasil.LanguageRenderer.CLike as C (float, double, char, 
  listType, void, notOp, andOp, orOp, self, litTrue, litFalse, litFloat, 
  inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs, listSize, increment1, 
  decrement1, varDec, varDecDef, listDec, extObjDecNew, switch, for, while, 
  intFunc, multiAssignError, multiReturnError, multiTypeError)
import qualified GOOL.Drasil.LanguageRenderer.Macros as M (ifExists, 
  runStrategy, listSlice, stringListVals, stringListLists, forRange, 
  notifyObservers, checkState)
import GOOL.Drasil.AST (Terminator(..), ScopeTag(..), qualName, FileType(..), 
  FileData(..), fileD, FuncData(..), fd, ModData(..), md, updateMod, 
  MethodData(..), mthd, updateMthd, OpData(..), ParamData(..), pd, ProgData(..),
  progD, TypeData(..), td, ValData(..), vd, VarData(..), vard)
import GOOL.Drasil.CodeAnalysis (Exception(..), ExceptionType(..), exception, 
  stdExc, HasException(..))
import GOOL.Drasil.Helpers (emptyIfNull, toCode, toState, onCodeValue, 
  onStateValue, on2CodeValues, on2StateValues, on3CodeValues, on3StateValues, 
  onCodeList, onStateList, on2StateWrapped)
import GOOL.Drasil.State (VS, lensGStoFS, lensMStoFS, lensMStoVS, lensVStoFS, 
  lensVStoMS, modifyReturn, modifyReturnList, revFiles, addProgNameToPaths, 
  addLangImport, addLangImportVS, addExceptionImports, getModuleName, 
  setFileType, getClassName, setCurrMain, setOutputsDeclared, 
  isOutputsDeclared, getExceptions, getMethodExcMap, addExceptions)

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)

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

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

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

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

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

instance OOProg JavaCode where

instance ProgramSym JavaCode where
  type Program JavaCode = ProgData
  prog :: String -> [SFile JavaCode] -> GSProgram JavaCode
prog n :: String
n fs :: [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 (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
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 -> [FileData] -> ProgData
progD String
n ([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 RenderSym JavaCode

instance FileSym JavaCode where
  type File JavaCode = FileData 
  fileDoc :: FSModule JavaCode -> SFile JavaCode
fileDoc m :: 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 :: * -> *).
RenderSym 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 -> SFile JavaCode -> SFile JavaCode
docMod = String
-> String -> [String] -> String -> SFile JavaCode -> SFile JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> String -> [String] -> String -> SFile r -> SFile r
CP.doxMod String
jExt

instance RenderFile JavaCode where
  top :: JavaCode (Module JavaCode) -> JavaCode (Block JavaCode)
top _ = 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 (BlockComment JavaCode)) -> SFile JavaCode
commentedMod = (JavaCode FileData -> JavaCode Doc -> JavaCode FileData)
-> StateT FileState Identity (JavaCode FileData)
-> State FileState (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 :: * -> *).
RenderSym 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 (Import JavaCode) -> Doc
forall a. JavaCode a -> a
unJC

instance PermanenceSym JavaCode where
  type Permanence JavaCode = Doc
  static :: JavaCode (Permanence JavaCode)
static = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.static
  dynamic :: JavaCode (Permanence JavaCode)
dynamic = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.dynamic

instance PermElim JavaCode where
  perm :: JavaCode (Permanence JavaCode) -> Doc
perm = JavaCode (Permanence JavaCode) -> Doc
forall a. JavaCode a -> a
unJC
  binding :: JavaCode (Permanence JavaCode) -> Binding
binding = String -> JavaCode (Permanence JavaCode) -> Binding
forall a. HasCallStack => String -> a
error (String -> JavaCode (Permanence JavaCode) -> Binding)
-> String -> JavaCode (Permanence JavaCode) -> Binding
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 s :: 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] -> MSBody JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
[MSBody r] -> MS (r Doc)
G.multiBody 

instance BodyElim JavaCode where
  body :: JavaCode (Body JavaCode) -> Doc
body = 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] -> MSBlock JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
[MSStatement r] -> MS (r Doc)
G.block

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

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

instance TypeSym JavaCode where
  type Type JavaCode = TypeData
  bool :: VSType JavaCode
bool = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
jBoolType
  int :: VSType JavaCode
int = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
CP.int
  float :: VSType JavaCode
float = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
C.float
  double :: VSType JavaCode
double = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
C.double
  char :: VSType JavaCode
char = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
C.char
  string :: VSType JavaCode
string = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
CP.string'
  infile :: VSType JavaCode
infile = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
jInfileType
  outfile :: VSType JavaCode
outfile = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
jOutfileType
  listType :: VSType JavaCode -> VSType JavaCode
listType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r -> VSType r
jListType
  arrayType :: VSType JavaCode -> VSType JavaCode
arrayType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r -> VSType r
CP.arrayType
  listInnerType :: VSType JavaCode -> VSType JavaCode
listInnerType = VSType JavaCode -> VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r -> VSType r
G.listInnerType
  obj :: String -> VSType JavaCode
obj = String -> VSType JavaCode
forall (r :: * -> *). RenderSym r => String -> VSType r
G.obj
  funcType :: [VSType JavaCode] -> VSType JavaCode -> VSType JavaCode
funcType = [VSType JavaCode] -> VSType JavaCode -> VSType JavaCode
forall (r :: * -> *).
RenderSym r =>
[VSType r] -> VSType r -> VSType r
CP.funcType
  void :: VSType JavaCode
void = VSType JavaCode
forall (r :: * -> *). RenderSym r => VSType r
C.void

instance TypeElim JavaCode where
  getType :: JavaCode (Type JavaCode) -> CodeType
getType = TypeData -> CodeType
cType (TypeData -> CodeType)
-> (JavaCode TypeData -> TypeData) -> JavaCode TypeData -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> TypeData
forall a. JavaCode a -> a
unJC
  getTypeString :: JavaCode (Type JavaCode) -> String
getTypeString = TypeData -> String
typeString (TypeData -> String)
-> (JavaCode TypeData -> TypeData) -> JavaCode TypeData -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> TypeData
forall a. JavaCode a -> a
unJC
  
instance RenderType JavaCode where
  multiType :: [VSType JavaCode] -> VSType JavaCode
multiType _ = 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
  typeFromData :: CodeType -> String -> Doc -> VSType JavaCode
typeFromData t :: CodeType
t s :: String
s d :: Doc
d = JavaCode TypeData -> VSType JavaCode
forall a s. a -> State s a
toState (JavaCode TypeData -> VSType JavaCode)
-> JavaCode TypeData -> VSType JavaCode
forall a b. (a -> b) -> a -> b
$ TypeData -> JavaCode TypeData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (TypeData -> JavaCode TypeData) -> TypeData -> JavaCode TypeData
forall a b. (a -> b) -> a -> b
$ CodeType -> String -> Doc -> TypeData
td CodeType
t String
s Doc
d

instance InternalTypeElim JavaCode where
  type' :: JavaCode (Type JavaCode) -> Doc
type' = TypeData -> Doc
typeDoc (TypeData -> Doc)
-> (JavaCode TypeData -> TypeData) -> JavaCode TypeData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode TypeData -> TypeData
forall a. JavaCode a -> a
unJC

instance UnaryOpSym JavaCode where
  type UnaryOp JavaCode = OpData
  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 -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.sqrt
  absOp :: VSUnOp JavaCode
absOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.abs
  logOp :: VSUnOp JavaCode
logOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.log10
  lnOp :: VSUnOp JavaCode
lnOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.log
  expOp :: VSUnOp JavaCode
expOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.exp
  sinOp :: VSUnOp JavaCode
sinOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.sin
  cosOp :: VSUnOp JavaCode
cosOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.cos
  tanOp :: VSUnOp JavaCode
tanOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.tan
  asinOp :: VSUnOp JavaCode
asinOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.asin
  acosOp :: VSUnOp JavaCode
acosOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.acos
  atanOp :: VSUnOp JavaCode
atanOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.atan
  floorOp :: VSUnOp JavaCode
floorOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.floor
  ceilOp :: VSUnOp JavaCode
ceilOp = String -> VSOp JavaCode
forall (r :: * -> *). Monad r => String -> VSOp r
jUnaryMath String
R.ceil

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

instance OpElim JavaCode where
  uOp :: JavaCode (UnaryOp JavaCode) -> 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 (BinaryOp JavaCode) -> 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 (UnaryOp JavaCode) -> 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 (BinaryOp JavaCode) -> 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 VariableSym JavaCode where
  type Variable JavaCode = VarData
  var :: String -> VSType JavaCode -> SVariable JavaCode
var = String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> SVariable r
G.var
  staticVar :: String -> VSType JavaCode -> SVariable JavaCode
staticVar = String -> VSType JavaCode -> SVariable JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> SVariable r
G.staticVar
  const :: String -> VSType JavaCode -> SVariable JavaCode
const = 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 :: * -> *).
RenderSym r =>
String -> String -> VSType r -> SVariable r
CP.extVar
  self :: SVariable JavaCode
self = SVariable JavaCode
forall (r :: * -> *). RenderSym r => SVariable r
C.self
  classVar :: VSType JavaCode -> SVariable JavaCode -> SVariable JavaCode
classVar = (Doc -> Doc -> Doc)
-> VSType JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc -> Doc) -> VSType r -> SVariable r -> SVariable r
CP.classVar Doc -> Doc -> Doc
R.classVar
  extClassVar :: VSType JavaCode -> SVariable JavaCode -> SVariable JavaCode
extClassVar = VSType JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
VSType r -> SVariable r -> SVariable r
classVar
  objVar :: SVariable JavaCode -> SVariable JavaCode -> SVariable JavaCode
objVar = SVariable JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SVariable r -> SVariable r
G.objVar
  objVarSelf :: SVariable JavaCode -> SVariable JavaCode
objVarSelf = SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> SVariable r
CP.objVarSelf
  arrayElem :: Integer -> SVariable JavaCode -> SVariable JavaCode
arrayElem i :: Integer
i = SValue JavaCode -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> SVariable r
G.arrayElem (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
i)

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 (Type JavaCode)
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) -> Binding
variableBind = VarData -> Binding
varBind (VarData -> Binding)
-> (JavaCode VarData -> VarData) -> JavaCode VarData -> Binding
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 :: Binding -> String -> VSType JavaCode -> Doc -> SVariable JavaCode
varFromData b :: Binding
b n :: String
n t' :: VSType JavaCode
t' d :: Doc
d =  do 
    JavaCode TypeData
t <- StateT ValueState Identity (JavaCode TypeData)
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 (Binding -> String -> TypeData -> Doc -> VarData
vard Binding
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 (Type JavaCode)
valueType = (ValData -> TypeData) -> JavaCode ValData -> JavaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ValData -> TypeData
valType

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

instance Literal JavaCode where
  litTrue :: SValue JavaCode
litTrue = SValue JavaCode
forall (r :: * -> *). RenderSym r => SValue r
C.litTrue
  litFalse :: SValue JavaCode
litFalse = SValue JavaCode
forall (r :: * -> *). RenderSym r => SValue r
C.litFalse
  litChar :: Char -> SValue JavaCode
litChar = (Doc -> Doc) -> Char -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc) -> Char -> SValue r
G.litChar Doc -> Doc
quotes
  litDouble :: Double -> SValue JavaCode
litDouble = Double -> SValue JavaCode
forall (r :: * -> *). RenderSym r => Double -> SValue r
G.litDouble
  litFloat :: Float -> SValue JavaCode
litFloat = Float -> SValue JavaCode
forall (r :: * -> *). RenderSym r => Float -> SValue r
C.litFloat
  litInt :: Integer -> SValue JavaCode
litInt = Integer -> SValue JavaCode
forall (r :: * -> *). RenderSym r => Integer -> SValue r
G.litInt
  litString :: String -> SValue JavaCode
litString = String -> SValue JavaCode
forall (r :: * -> *). RenderSym r => String -> SValue r
G.litString
  litArray :: VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
litArray = (Doc -> Doc)
-> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc) -> VSType r -> [SValue r] -> SValue r
CP.litArray Doc -> Doc
braces
  litList :: VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
litList t :: VSType JavaCode
t es :: [SValue JavaCode]
es = do
    LensLike'
  (Zoomed (StateT MethodState Identity) ()) ValueState MethodState
-> StateT MethodState Identity () -> StateT ValueState Identity ()
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 (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 :: * -> *). ValueExpression 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 (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 :: * -> *). RenderSym r => SValue r
CP.pi

instance VariableValue JavaCode where
  valueOf :: SVariable JavaCode -> SValue JavaCode
valueOf = SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> SValue r
G.valueOf

instance CommandLineArgs JavaCode where
  arg :: Integer -> SValue JavaCode
arg n :: Integer
n = SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *). RenderSym r => String -> SValue r
G.argsList String
args
  argExists :: Integer -> SValue JavaCode
argExists i :: 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sqrtOp
  #| :: SValue JavaCode -> SValue JavaCode
(#|) = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#+) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  #- :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#-) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp
  #* :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#*) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  #/ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#/) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp
  #% :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#%) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(#^) = VSBinOp JavaCode
-> SValue JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExprNumDbl' VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp

  log :: SValue JavaCode -> SValue JavaCode
log = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: SValue JavaCode -> SValue JavaCode
ln = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: SValue JavaCode -> SValue JavaCode
exp = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: SValue JavaCode -> SValue JavaCode
sin = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: SValue JavaCode -> SValue JavaCode
cos = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: SValue JavaCode -> SValue JavaCode
tan = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: SValue JavaCode -> SValue JavaCode
csc = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
G.csc
  sec :: SValue JavaCode -> SValue JavaCode
sec = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
G.sec
  cot :: SValue JavaCode -> SValue JavaCode
cot = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
G.cot
  arcsin :: SValue JavaCode -> SValue JavaCode
arcsin = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: SValue JavaCode -> SValue JavaCode
arccos = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: SValue JavaCode -> SValue JavaCode
arctan = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp JavaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: SValue JavaCode -> SValue JavaCode
floor = VSUnOp JavaCode -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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
(?&&) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?|| :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?||) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp 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
(?<) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?<= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?<=) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?> :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?>= :: SValue JavaCode -> SValue JavaCode -> SValue JavaCode
(?>=) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp 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
(?!=) = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp 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 :: * -> *).
RenderSym 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 n :: String
n t :: VSType JavaCode
t vs :: [SValue JavaCode]
vs ns :: NamedArgs JavaCode
ns = do
    String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n 
    MixedCall JavaCode
forall (r :: * -> *). RenderSym r => MixedCall r
G.funcAppMixedArgs String
n VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns
  selfFuncAppMixedArgs :: MixedCall JavaCode
selfFuncAppMixedArgs n :: String
n t :: VSType JavaCode
t ps :: [SValue JavaCode]
ps ns :: NamedArgs JavaCode
ns = do
    String -> StateT ValueState Identity ()
addCallExcsCurrMod String
n
    Doc -> SVariable JavaCode -> MixedCall JavaCode
forall (r :: * -> *).
RenderSym r =>
Doc -> SVariable r -> MixedCall r
G.selfFuncAppMixedArgs Doc
dot SVariable JavaCode
forall (r :: * -> *). VariableSym r => SVariable r
self String
n VSType JavaCode
t [SValue JavaCode]
ps NamedArgs JavaCode
ns
  extFuncAppMixedArgs :: String -> MixedCall JavaCode
extFuncAppMixedArgs l :: String
l n :: String
n t :: VSType JavaCode
t vs :: [SValue JavaCode]
vs ns :: 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 :: * -> *). RenderSym r => String -> MixedCall r
CP.extFuncAppMixedArgs String
l String
n VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns
  libFuncAppMixedArgs :: String -> MixedCall JavaCode
libFuncAppMixedArgs = String -> MixedCall JavaCode
forall (r :: * -> *). RenderSym r => String -> MixedCall r
C.libFuncAppMixedArgs
  newObjMixedArgs :: MixedCtorCall JavaCode
newObjMixedArgs ot :: VSType JavaCode
ot vs :: [SValue JavaCode]
vs ns :: NamedArgs JavaCode
ns = VSType JavaCode
-> (VSType JavaCode -> SValue JavaCode) -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSType r -> (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod VSType JavaCode
ot (\t :: VSType JavaCode
t -> 
    MixedCall JavaCode
forall (r :: * -> *). RenderSym r => MixedCall r
G.newObjMixedArgs (String
new String -> String -> String
forall a. [a] -> [a] -> [a]
++ " ") VSType JavaCode
t [SValue JavaCode]
vs NamedArgs JavaCode
ns)
  extNewObjMixedArgs :: MixedCall JavaCode
extNewObjMixedArgs l :: String
l ot :: VSType JavaCode
ot vs :: [SValue JavaCode]
vs ns :: NamedArgs JavaCode
ns = do
    JavaCode TypeData
t <- StateT ValueState Identity (JavaCode TypeData)
VSType JavaCode
ot
    Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
    let tp :: String
tp = JavaCode (Type JavaCode) -> String
forall (r :: * -> *). TypeElim r => r (Type r) -> String
getTypeString JavaCode TypeData
JavaCode (Type JavaCode)
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 :: * -> *). ValueExpression r => MixedCtorCall r
newObjMixedArgs (JavaCode TypeData -> StateT ValueState Identity (JavaCode TypeData)
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 :: * -> *). RenderSym r => MixedCall r
C.libNewObjMixedArgs

  lambda :: [SVariable JavaCode] -> SValue JavaCode -> SValue JavaCode
lambda = ([JavaCode (Variable JavaCode)]
 -> JavaCode (Value JavaCode) -> Doc)
-> [SVariable JavaCode] -> SValue JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
([r (Variable r)] -> r (Value r) -> Doc)
-> [SVariable r] -> SValue r -> SValue r
G.lambda [JavaCode (Variable JavaCode)] -> JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *).
RenderSym r =>
[r (Variable r)] -> r (Value r) -> Doc
jLambda

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

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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal 
    (String -> VSType JavaCode
forall (r :: * -> *). TypeSym 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 :: * -> *). RenderSym 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 :: * -> *). RenderSym 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))
-> StateT ValueState Identity (JavaCode TypeData)
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\v :: JavaCode TypeData
v -> JavaCode (Type JavaCode) -> Doc -> SValue JavaCode
forall (r :: * -> *). RenderSym r => r (Type r) -> Doc -> SValue r
mkVal JavaCode TypeData
JavaCode (Type JavaCode)
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
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value) StateT ValueState Identity (JavaCode TypeData)
forall (r :: * -> *). TypeSym r => VSType r
void
  printFileLnFunc :: SValue JavaCode -> SValue JavaCode
printFileLnFunc = (JavaCode TypeData -> JavaCode ValData -> VS (JavaCode ValData))
-> StateT ValueState Identity (JavaCode TypeData)
-> VS (JavaCode ValData)
-> VS (JavaCode ValData)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\v :: JavaCode TypeData
v -> JavaCode (Type JavaCode) -> Doc -> SValue JavaCode
forall (r :: * -> *). RenderSym r => r (Type r) -> Doc -> SValue r
mkVal JavaCode TypeData
JavaCode (Type JavaCode)
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
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value) StateT ValueState Identity (JavaCode TypeData)
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 :: * -> *).
RenderSym r =>
String -> Maybe String -> Maybe Doc -> MixedCall r
CP.call' String
jName
  
  valFromData :: Maybe Int -> VSType JavaCode -> Doc -> SValue JavaCode
valFromData p :: Maybe Int
p t' :: VSType JavaCode
t' d :: Doc
d = do 
    JavaCode TypeData
t <- StateT ValueState Identity (JavaCode TypeData)
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 -> TypeData -> Doc -> ValData
vd Maybe Int
p) 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
  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' f :: String
f t :: VSType JavaCode
t o :: SValue JavaCode
o ps :: [SValue JavaCode]
ps ns :: 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 (Type JavaCode) -> String
forall (r :: * -> *). TypeElim r => r (Type r) -> String
getTypeString (JavaCode (Value JavaCode) -> JavaCode (Type JavaCode)
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
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 :: * -> *).
RenderSym 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

instance FunctionSym JavaCode where
  type Function JavaCode = FuncData
  func :: String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
func = String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> SValue r -> SValue r
G.set

instance List JavaCode where
  listSize :: SValue JavaCode -> SValue JavaCode
listSize = SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
String -> SValue r -> SValue r -> SValue r
CP.indexOf String
jIndex

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 :: * -> *).
RenderSym 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 :: * -> *). RenderSym 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 :: * -> *).
RenderSym r =>
VSType r -> SVariable r -> SValue r -> VSFunction r
G.setFunc

instance InternalListFunc JavaCode where
  listSizeFunc :: VSFunction JavaCode
listSizeFunc = VSFunction JavaCode
forall (r :: * -> *). RenderSym r => VSFunction r
CP.listSizeFunc
  listAddFunc :: SValue JavaCode
-> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
listAddFunc _ = String -> SValue JavaCode -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> SValue r -> VSFunction r
CP.listAddFunc String
jListAdd
  listAppendFunc :: SValue JavaCode -> VSFunction JavaCode
listAppendFunc = String -> SValue JavaCode -> VSFunction JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
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 RenderFunction JavaCode where
  funcFromData :: Doc -> VSType JavaCode -> VSFunction JavaCode
funcFromData d :: Doc
d = (JavaCode TypeData -> JavaCode FuncData)
-> StateT ValueState Identity (JavaCode TypeData)
-> 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 (Type JavaCode)
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 _ _ = 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 _ _ = SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> MSStatement r
CP.printSt

instance InternalControlStmt JavaCode where
  multiReturn :: [SValue JavaCode] -> MSStatement JavaCode
multiReturn _ = 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 :: * -> *). RenderSym r => MSStatement r -> MSStatement r
G.stmt
  loopStmt :: MSStatement JavaCode -> MSStatement JavaCode
loopStmt = MSStatement JavaCode -> MSStatement JavaCode
forall (r :: * -> *). RenderSym r => MSStatement r -> MSStatement r
G.loopStmt

  emptyStmt :: MSStatement JavaCode
emptyStmt = MSStatement JavaCode
forall (r :: * -> *). RenderSym r => MSStatement r
G.emptyStmt
  
  stmtFromData :: Doc -> Terminator -> MSStatement JavaCode
stmtFromData d :: Doc
d t :: Terminator
t = JavaCode (Doc, Terminator) -> MSStatement JavaCode
forall a s. a -> State s a
toState (JavaCode (Doc, Terminator) -> MSStatement JavaCode)
-> JavaCode (Doc, Terminator) -> 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 :: * -> *).
RenderSym r =>
Terminator -> SValue r -> MSStatement r
G.valStmt Terminator
Semi
  multi :: [MSStatement JavaCode] -> MSStatement JavaCode
multi = ([JavaCode (Doc, Terminator)] -> JavaCode (Doc, Terminator))
-> [State MethodState (JavaCode (Doc, Terminator))]
-> State MethodState (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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
SVariable r -> SValue r -> MSStatement r
G.increment
  &++ :: SVariable JavaCode -> MSStatement JavaCode
(&++) = SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> MSStatement r
C.increment1
  &-- :: SVariable JavaCode -> MSStatement JavaCode
(&--) = SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> MSStatement r
C.decrement1

instance DeclStatement JavaCode where
  varDec :: SVariable JavaCode -> MSStatement JavaCode
varDec = JavaCode (Permanence JavaCode)
-> JavaCode (Permanence JavaCode)
-> Doc
-> SVariable JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
r (Permanence r)
-> r (Permanence r) -> Doc -> SVariable r -> MSStatement r
C.varDec JavaCode (Permanence JavaCode)
forall (r :: * -> *). PermanenceSym r => r (Permanence r)
static JavaCode (Permanence JavaCode)
forall (r :: * -> *). PermanenceSym r => r (Permanence r)
dynamic Doc
empty
  varDecDef :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
varDecDef = Terminator
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
C.varDecDef Terminator
Semi
  listDec :: Integer -> SVariable JavaCode -> MSStatement JavaCode
listDec n :: Integer
n v :: SVariable JavaCode
v = LensLike'
  (Zoomed (StateT ValueState Identity) (JavaCode VarData))
  MethodState
  ValueState
-> State ValueState (JavaCode VarData)
-> StateT MethodState Identity (JavaCode VarData)
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
Lens' MethodState ValueState
lensMStoVS State ValueState (JavaCode VarData)
SVariable JavaCode
v StateT MethodState Identity (JavaCode VarData)
-> (JavaCode VarData
    -> State MethodState (JavaCode (Doc, Terminator)))
-> State MethodState (JavaCode (Doc, Terminator))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\v' :: JavaCode VarData
v' -> (JavaCode (Value JavaCode) -> Doc)
-> SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
(r (Value r) -> Doc) -> SValue r -> SVariable r -> MSStatement r
C.listDec (JavaCode (Variable JavaCode) -> JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *).
RenderSym r =>
r (Variable r) -> r (Value r) -> Doc
R.listDec JavaCode VarData
JavaCode (Variable JavaCode)
v') 
    (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n) SVariable JavaCode
v)
  listDecDef :: SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
listDecDef = SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
CP.listDecDef
  arrayDec :: Integer -> SVariable JavaCode -> MSStatement JavaCode
arrayDec n :: Integer
n = SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> MSStatement r
CP.arrayDec (Integer -> SValue JavaCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n)
  arrayDecDef :: SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
arrayDecDef = SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
CP.arrayDecDef
  objDecDef :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
objDecDef = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> SValue r -> MSStatement r
varDecDef
  objDecNew :: SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
objDecNew = SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
G.objDecNew
  extObjDecNew :: String
-> SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
extObjDecNew = String
-> SVariable JavaCode -> [SValue JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> SVariable r -> [SValue r] -> MSStatement r
C.extObjDecNew
  constDecDef :: SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
constDecDef = SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SValue r -> MSStatement r
jConstDecDef
  funcDecDef :: SVariable JavaCode
-> [SVariable JavaCode] -> MSBody JavaCode -> MSStatement JavaCode
funcDecDef = SVariable JavaCode
-> [SVariable JavaCode] -> MSBody JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SVariable r] -> MSBody r -> MSStatement r
jFuncDecDef

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

  printFile :: SValue JavaCode -> SValue JavaCode -> MSStatement JavaCode
printFile f :: SValue JavaCode
f      = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
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 f :: SValue JavaCode
f    = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
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 f :: SValue JavaCode
f   = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
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)
 -> State MethodState (JavaCode (Doc, Terminator)))
-> (String -> VS (JavaCode ValData))
-> String
-> State MethodState (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (JavaCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printFileStrLn :: SValue JavaCode -> String -> MSStatement JavaCode
printFileStrLn f :: SValue JavaCode
f = Bool
-> Maybe (SValue JavaCode)
-> SValue JavaCode
-> SValue JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
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)
 -> State MethodState (JavaCode (Doc, Terminator)))
-> (String -> VS (JavaCode ValData))
-> String
-> State MethodState (JavaCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (JavaCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString

  getInput :: SVariable JavaCode -> MSStatement JavaCode
getInput v :: 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 f :: SValue JavaCode
f v :: 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 :: * -> *).
RenderSym r =>
(SValue r -> VSType r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileR SValue JavaCode -> VSType JavaCode -> SValue JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA
  closeFile :: SValue JavaCode -> MSStatement JavaCode
closeFile = String -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> MSStatement r
G.closeFile String
jClose

  getFileInputLine :: SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
getFileInputLine f :: SValue JavaCode
f v :: 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 :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
  discardFileLine :: SValue JavaCode -> MSStatement JavaCode
discardFileLine = String -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> MSStatement r
CP.discardFileLine String
jNextLine
  getFileInputAll :: SValue JavaCode -> SVariable JavaCode -> MSStatement JavaCode
getFileInputAll f :: SValue JavaCode
f v :: 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 :: * -> *).
FunctionSym 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 :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc))

instance StringStatement JavaCode where
  stringSplit :: Char
-> SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
stringSplit d :: Char
d vnew :: SVariable JavaCode
vnew s :: 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 (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
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
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SValue r -> 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 :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. Char -> VSFunction JavaCode
forall (r :: * -> *). RenderSym r => Char -> VSFunction r
jSplitFunc Char
d])
    Doc -> MSStatement JavaCode
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt Doc
ss 

  stringListVals :: [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
stringListVals = [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
[SVariable r] -> SValue r -> MSStatement r
M.stringListVals
  stringListLists :: [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
stringListLists = [SVariable JavaCode] -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
[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
  selfInOutCall :: InOutCall JavaCode
selfInOutCall = (String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode)
-> InOutCall JavaCode
jInOutCall String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
forall (r :: * -> *). ValueExpression r => PosCall r
selfFuncApp
  extInOutCall :: String -> InOutCall JavaCode
extInOutCall m :: 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 CommentStatement JavaCode where
  comment :: String -> MSStatement JavaCode
comment = Doc -> String -> MSStatement JavaCode
forall (r :: * -> *). RenderSym r => Doc -> String -> MSStatement r
G.comment Doc
commentStart

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

  returnStmt :: SValue JavaCode -> MSStatement JavaCode
returnStmt = Terminator -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
(r (Value r) -> Doc) -> Terminator -> String -> MSStatement r
G.throw JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). RenderSym r => r (Value r) -> Doc
jThrowDoc Terminator
Semi

  ifCond :: [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode -> MSStatement JavaCode
ifCond = (Doc -> Doc)
-> Doc
-> Doc
-> Doc
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc)
-> Doc
-> Doc
-> Doc
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
G.ifCond Doc -> Doc
parens Doc
bodyStart Doc
elseIfLabel Doc
bodyEnd
  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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
r (Body r) -> r (Body r) -> Doc
jTryCatch
  
instance StatePattern JavaCode where 
  checkState :: String
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
checkState = String
-> [(SValue JavaCode, MSBody JavaCode)]
-> MSBody JavaCode
-> MSStatement JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> [(SValue r, MSBody r)] -> MSBody r -> MSStatement r
M.checkState

instance ObserverPattern JavaCode where
  notifyObservers :: VSFunction JavaCode -> VSType JavaCode -> MSStatement JavaCode
notifyObservers = VSFunction JavaCode -> VSType JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
RenderSym 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)
-> MSBlock JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
String
-> [(String, MSBody r)]
-> Maybe (SValue r)
-> Maybe (SVariable r)
-> MS (r Doc)
M.runStrategy

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

instance RenderScope JavaCode where
  scopeFromData :: ScopeTag -> Doc -> JavaCode (Scope JavaCode)
scopeFromData _ = Doc -> JavaCode (Scope JavaCode)
forall (r :: * -> *) a. Monad r => a -> r a
toCode
  
instance ScopeElim JavaCode where
  scope :: JavaCode (Scope JavaCode) -> Doc
scope = JavaCode (Scope 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
-> StateT ValueState Identity (JavaCode TypeData)
-> StateT MethodState Identity (JavaCode TypeData)
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
Lens' MethodState ValueState
lensMStoVS
  construct :: String -> MSMthdType JavaCode
construct = String -> MSMthdType JavaCode
forall (r :: * -> *). RenderSym r => String -> MS (r (Type r))
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 :: * -> *).
RenderSym r =>
(r (Variable r) -> Doc) -> SVariable r -> MSParameter r
G.param JavaCode (Variable JavaCode) -> Doc
forall (r :: * -> *). RenderSym r => r (Variable r) -> Doc
R.param
  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 v' :: SVariable JavaCode
v' d :: 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 (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
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
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 (Type JavaCode)
parameterType = JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
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
  method :: String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
method = String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
RenderSym r =>
String
-> r (Scope r)
-> r (Permanence r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
G.method
  getMethod :: SVariable JavaCode -> SMethod JavaCode
getMethod = SVariable JavaCode -> SMethod JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> SMethod r
G.getMethod
  setMethod :: SVariable JavaCode -> SMethod JavaCode
setMethod = SVariable JavaCode -> SMethod JavaCode
forall (r :: * -> *). RenderSym r => SVariable r -> SMethod r
G.setMethod
  constructor :: [MSParameter JavaCode]
-> NamedArgs JavaCode -> MSBody JavaCode -> SMethod JavaCode
constructor ps :: [MSParameter JavaCode]
ps is :: NamedArgs JavaCode
is b :: MSBody JavaCode
b = MS String
getClassName MS String
-> (String -> StateT MethodState Identity (JavaCode MethodData))
-> StateT MethodState Identity (JavaCode MethodData)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\n :: String
n -> String
-> [MSParameter JavaCode]
-> NamedArgs JavaCode
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
RenderSym r =>
String
-> [MSParameter r] -> Initializers r -> MSBody r -> SMethod r
CP.constructor String
n [MSParameter JavaCode]
ps NamedArgs JavaCode
is MSBody JavaCode
b)

  docMain :: MSBody JavaCode -> SMethod JavaCode
docMain = MSBody JavaCode -> SMethod JavaCode
forall (r :: * -> *). RenderSym r => MSBody r -> SMethod r
CP.docMain

  function :: String
-> JavaCode (Scope JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
function = String
-> JavaCode (Scope JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
RenderSym r =>
String
-> r (Scope 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
String -> [String] -> Maybe String -> SMethod r -> SMethod r
CP.doxFunc

  inOutMethod :: String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> InOutFunc JavaCode
inOutMethod n :: String
n s :: JavaCode (Scope JavaCode)
s p :: JavaCode (Permanence JavaCode)
p = (VSType JavaCode
 -> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode)
-> InOutFunc JavaCode
jInOut (String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
MethodSym r =>
String
-> r (Scope r)
-> r (Permanence r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
method String
n JavaCode (Scope JavaCode)
s JavaCode (Permanence JavaCode)
p)

  docInOutMethod :: String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> DocInOutFunc JavaCode
docInOutMethod n :: String
n s :: JavaCode (Scope JavaCode)
s p :: JavaCode (Permanence JavaCode)
p = InOutFunc JavaCode -> DocInOutFunc JavaCode
forall (r :: * -> *).
RenderSym 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 (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> InOutFunc JavaCode
forall (r :: * -> *).
MethodSym r =>
String -> r (Scope r) -> r (Permanence r) -> InOutFunc r
inOutMethod String
n JavaCode (Scope JavaCode)
s JavaCode (Permanence JavaCode)
p)

  inOutFunc :: String -> JavaCode (Scope JavaCode) -> InOutFunc JavaCode
inOutFunc n :: String
n s :: JavaCode (Scope JavaCode)
s = (VSType JavaCode
 -> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode)
-> InOutFunc JavaCode
jInOut (String
-> JavaCode (Scope JavaCode)
-> VSType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
MethodSym r =>
String
-> r (Scope r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
function String
n JavaCode (Scope JavaCode)
s)
    
  docInOutFunc :: String -> JavaCode (Scope JavaCode) -> DocInOutFunc JavaCode
docInOutFunc n :: String
n s :: JavaCode (Scope JavaCode)
s = InOutFunc JavaCode -> DocInOutFunc JavaCode
forall (r :: * -> *).
RenderSym 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 (Scope JavaCode) -> InOutFunc JavaCode
forall (r :: * -> *).
MethodSym r =>
String -> r (Scope r) -> InOutFunc r
inOutFunc String
n JavaCode (Scope JavaCode)
s)

instance RenderMethod JavaCode where
  intMethod :: Bool
-> String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
intMethod m :: Bool
m n :: String
n s :: JavaCode (Scope JavaCode)
s p :: JavaCode (Permanence JavaCode)
p t :: MSMthdType JavaCode
t ps :: [MSParameter JavaCode]
ps b :: 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)
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 (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
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 (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
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 (m :: * -> *) a. Monad m => a -> m a
return (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 (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> JavaCode (Type JavaCode)
-> [JavaCode (Parameter JavaCode)]
-> JavaCode (Body JavaCode)
-> Doc
forall (r :: * -> *).
RenderSym r =>
String
-> [String]
-> r (Scope r)
-> r (Permanence r)
-> r (Type r)
-> [r (Parameter r)]
-> r (Body r)
-> Doc
jMethod String
n ((Exception -> String) -> [Exception] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Exception -> String
exc [Exception]
excs) JavaCode (Scope JavaCode)
s JavaCode (Permanence JavaCode)
p JavaCode TypeData
JavaCode (Type JavaCode)
tp [JavaCode ParamData]
[JavaCode (Parameter JavaCode)]
pms JavaCode Doc
JavaCode (Body JavaCode)
bd
  intFunc :: Bool
-> String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
intFunc = Bool
-> String
-> JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> MSMthdType JavaCode
-> [MSParameter JavaCode]
-> MSBody JavaCode
-> SMethod JavaCode
forall (r :: * -> *).
RenderSym r =>
Bool
-> String
-> r (Scope r)
-> r (Permanence r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
C.intFunc
  commentedFunc :: MS (JavaCode (BlockComment JavaCode))
-> SMethod JavaCode -> SMethod JavaCode
commentedFunc cmt :: MS (JavaCode (BlockComment JavaCode))
cmt m :: 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)
MS (JavaCode (BlockComment JavaCode))
cmt)
    
  destructor :: [CSStateVar JavaCode] -> SMethod JavaCode
destructor _ = 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
  
  mthdFromData :: ScopeTag -> Doc -> SMethod JavaCode
mthdFromData _ d :: Doc
d = JavaCode MethodData -> SMethod JavaCode
forall a s. a -> State s a
toState (JavaCode MethodData -> SMethod JavaCode)
-> JavaCode MethodData -> 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 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 (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> SVariable JavaCode
-> CSStateVar JavaCode
stateVar = JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> SVariable JavaCode
-> CSStateVar JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
r (Scope r) -> r (Permanence r) -> SVariable r -> CS (r Doc)
CP.stateVar
  stateVarDef :: JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode
stateVarDef = JavaCode (Scope JavaCode)
-> JavaCode (Permanence JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CSStateVar JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
r (Scope r)
-> r (Permanence r) -> SVariable r -> SValue r -> CS (r Doc)
CP.stateVarDef
  constVar :: JavaCode (Scope JavaCode)
-> SVariable JavaCode -> SValue JavaCode -> CSStateVar JavaCode
constVar = Doc
-> JavaCode (Scope JavaCode)
-> SVariable JavaCode
-> SValue JavaCode
-> CS (JavaCode Doc)
forall (r :: * -> *).
(RenderSym r, Monad r) =>
Doc -> r (Scope r) -> SVariable r -> SValue r -> CS (r Doc)
CP.constVar (JavaCode (Permanence JavaCode) -> Doc
forall (r :: * -> *). PermElim r => r (Permanence r) -> Doc
RC.perm (JavaCode (Permanence JavaCode)
forall (r :: * -> *). PermanenceSym r => r (Permanence r)
static :: JavaCode (Permanence JavaCode)))
  
instance StateVarElim JavaCode where
  stateVar :: JavaCode (StateVar JavaCode) -> Doc
stateVar = 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] -> SClass JavaCode
buildClass = Maybe String
-> [CSStateVar JavaCode] -> [SMethod JavaCode] -> SClass JavaCode
forall (r :: * -> *).
RenderSym r =>
Maybe String -> [CSStateVar r] -> [SMethod r] -> SClass r
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
extraClass = String
-> Maybe String
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> Maybe String -> [CSStateVar r] -> [SMethod r] -> SClass r
jExtraClass
  implementingClass :: String
-> [String]
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
implementingClass = String
-> [String]
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
forall (r :: * -> *).
RenderSym r =>
String -> [String] -> [CSStateVar r] -> [SMethod r] -> SClass r
G.implementingClass

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

instance RenderClass JavaCode where
  intClass :: String
-> JavaCode (Scope JavaCode)
-> JavaCode Doc
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> SClass JavaCode
intClass = (String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> JavaCode (Scope JavaCode)
-> JavaCode Doc
-> [CSStateVar JavaCode]
-> [SMethod JavaCode]
-> CS (JavaCode Doc)
forall (r :: * -> *).
(RenderSym r, Monad r) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r (Scope r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> CS (r Doc)
CP.intClass String -> Doc -> Doc -> Doc -> Doc -> Doc
R.class'
  
  inherit :: Maybe String -> JavaCode Doc
inherit n :: Maybe String
n = Doc -> JavaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode Doc) -> Doc -> JavaCode Doc
forall a b. (a -> b) -> a -> b
$ Doc -> (String -> Doc) -> Maybe String -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty ((Doc
jExtends Doc -> Doc -> Doc
<+>) (Doc -> Doc) -> (String -> Doc) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
text) Maybe String
n
  implements :: [String] -> JavaCode Doc
implements is :: [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 (BlockComment JavaCode))
-> SClass JavaCode -> SClass JavaCode
commentedClass = CS (JavaCode (BlockComment JavaCode))
-> SClass JavaCode -> SClass JavaCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
CS (r (BlockComment r)) -> SClass r -> CS (r Doc)
G.commentedClass
  
instance ClassElim JavaCode where
  class' :: JavaCode (Class JavaCode) -> Doc
class' = 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 n :: String
n = String
-> (String -> JavaCode (Import JavaCode))
-> [String]
-> [SMethod JavaCode]
-> [SClass JavaCode]
-> FSModule JavaCode
forall (r :: * -> *).
RenderSym 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 n :: 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 f :: 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
  type BlockComment JavaCode = Doc
  blockComment :: [String] -> JavaCode (BlockComment JavaCode)
blockComment lns :: [String]
lns = Doc -> JavaCode (BlockComment JavaCode)
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JavaCode (BlockComment JavaCode))
-> Doc -> JavaCode (BlockComment JavaCode)
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.blockCmt [String]
lns Doc
blockCmtStart Doc
blockCmtEnd
  docComment :: State a [String] -> State a (JavaCode (BlockComment JavaCode))
docComment = ([String] -> JavaCode Doc)
-> State a [String] -> State a (JavaCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\lns :: [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 (BlockComment JavaCode) -> Doc
blockComment' = JavaCode (BlockComment JavaCode) -> Doc
forall a. JavaCode a -> a
unJC

instance HasException JavaCode where
  toConcreteExc :: ExceptionType -> JavaCode Exception
toConcreteExc 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 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 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 = "Java"
jVersion :: String
jVersion = "14"

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

jBoolType :: (RenderSym r) => VSType r
jBoolType :: VSType r
jBoolType = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Boolean String
jBool (String -> Doc
text String
jBool)

jInfileType :: (RenderSym r) => VSType r
jInfileType :: VSType r
jInfileType = do 
  r (Type r)
tpf <- CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
InFile String
jScanner Doc
jScanner'
  (ValueState -> ValueState) -> r (Type r) -> 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 (Type r)
tpf

jOutfileType :: (RenderSym r) => VSType r
jOutfileType :: VSType r
jOutfileType = do 
  r (Type r)
tpf <- CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
OutFile String
jPrintWriter (String -> Doc
text String
jPrintWriter)
  (ValueState -> ValueState) -> r (Type r) -> 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 (Type r)
tpf

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

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

javaImport, ioImport, utilImport :: String -> String
javaImport :: String -> String
javaImport = String -> String -> String
access "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 "System"

jUnaryMath :: (Monad r) => String -> VSOp r
jUnaryMath :: 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 :: (RenderSym r) => VSType r -> VSType r
jListType :: VSType r -> VSType r
jListType t :: 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 (Type r) -> VSType r) -> VSType r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (CodeType -> VSType r
jListType' (CodeType -> VSType r)
-> (r (Type r) -> CodeType) -> r (Type r) -> VSType r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType)
  where jListType' :: CodeType -> VSType r
jListType' Integer = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
List CodeType
Integer) 
          String
lstInt (String -> Doc
text String
lstInt)
        jListType' Float = String -> VSType r -> VSType r
forall (r :: * -> *). RenderSym r => String -> VSType r -> VSType r
C.listType String
arrayList VSType r
forall (r :: * -> *). RenderSym r => VSType r
CP.float
        jListType' Double = String -> VSType r -> VSType r
forall (r :: * -> *). RenderSym r => String -> VSType r -> VSType r
C.listType String
arrayList VSType r
forall (r :: * -> *). RenderSym r => VSType r
CP.double
        jListType' Boolean = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
List CodeType
Boolean) String
lstBool (String -> Doc
text String
lstBool)
        jListType' _ = String -> VSType r -> VSType r
forall (r :: * -> *). RenderSym r => 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'

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 :: * -> *). TypeSym r => String -> VSType r
obj String
jObject)

jFileType :: (RenderSym r) => VSType r
jFileType :: VSType r
jFileType = do 
  r (Type r)
tpf <- String -> VSType r
forall (r :: * -> *). TypeSym r => String -> VSType r
obj String
jFile
  (ValueState -> ValueState) -> r (Type r) -> 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 (Type r)
tpf

jFileWriterType :: (RenderSym r) => VSType r
jFileWriterType :: VSType r
jFileWriterType = do 
  r (Type r)
tpf <- String -> VSType r
forall (r :: * -> *). TypeSym r => String -> VSType r
obj String
jFileWriter
  (ValueState -> ValueState) -> r (Type r) -> 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 (Type r)
tpf

jAsListFunc :: VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc :: VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
jAsListFunc t :: 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 v :: SValue JavaCode
v = String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
forall (r :: * -> *).
FunctionSym 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 v :: 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 v :: 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 v :: 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 v :: SValue JavaCode
v i :: SValue JavaCode
i toVal :: SValue JavaCode
toVal = String
-> VSType JavaCode -> [SValue JavaCode] -> VSFunction JavaCode
forall (r :: * -> *).
FunctionSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
func String
jListSet ((JavaCode ValData -> JavaCode TypeData)
-> VS (JavaCode ValData)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode ValData -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType VS (JavaCode ValData)
SValue JavaCode
v) [SValue JavaCode -> SValue JavaCode
forall (r :: * -> *). RenderSym r => 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 :: * -> *).
FunctionSym 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 :: * -> *).
FunctionSym 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 :: * -> *).
FunctionSym 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 :: * -> *).
FunctionSym 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 :: * -> *).
FunctionSym 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 0]

jSplitFunc :: (RenderSym r) => Char -> VSFunction r
jSplitFunc :: Char -> VSFunction r
jSplitFunc d :: Char
d = String -> VSType r -> [SValue r] -> VSFunction r
forall (r :: * -> *).
FunctionSym 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 v1 :: SValue JavaCode
v1 v2 :: SValue JavaCode
v2 = VS (JavaCode ValData)
SValue JavaCode
v2 VS (JavaCode ValData)
-> (JavaCode ValData -> VS (JavaCode ValData))
-> VS (JavaCode ValData)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> VS (JavaCode ValData)
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 :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (JavaCode TypeData -> CodeType)
-> (JavaCode ValData -> JavaCode TypeData)
-> JavaCode ValData
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaCode ValData -> JavaCode TypeData
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType
  where jEquality' :: CodeType -> VS (JavaCode ValData)
jEquality' String = SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
objAccess SValue JavaCode
v1 (SValue JavaCode -> VSFunction JavaCode
jEqualsFunc SValue JavaCode
v2)
        jEquality' _ = VSBinOp JavaCode
-> VSType JavaCode
-> SValue JavaCode
-> SValue JavaCode
-> SValue JavaCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp JavaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
bool SValue JavaCode
v1 SValue JavaCode
v2

jLambda :: (RenderSym r) => [r (Variable r)] -> r (Value r) -> Doc
jLambda :: [r (Variable r)] -> r (Value r) -> Doc
jLambda ps :: [r (Variable r)]
ps ex :: r (Value r)
ex = Doc -> Doc
parens ([r (Variable r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Variable r)] -> Doc
variableList [r (Variable r)]
ps) Doc -> Doc -> Doc
<+> Doc
jLambdaSep Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
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))
-> (StateT ValueState Identity (JavaCode TypeData)
    -> VS (JavaCode ValData)
    -> StateT ValueState Identity (VS (JavaCode ValData)))
-> StateT ValueState Identity (JavaCode TypeData)
-> 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))
-> StateT ValueState Identity (JavaCode TypeData)
-> 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 (\t :: JavaCode TypeData
t v :: JavaCode ValData
v -> CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode ValData
-> VS (JavaCode ValData)
jCast' (JavaCode (Type JavaCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType JavaCode TypeData
JavaCode (Type JavaCode)
t) (JavaCode (Type JavaCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (JavaCode (Type JavaCode) -> CodeType)
-> JavaCode (Type JavaCode) -> CodeType
forall a b. (a -> b) -> a -> b
$ JavaCode (Value JavaCode) -> JavaCode (Type JavaCode)
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType 
  JavaCode ValData
JavaCode (Value JavaCode)
v) JavaCode TypeData
t JavaCode ValData
v)
  where jCast' :: CodeType
-> CodeType
-> JavaCode TypeData
-> JavaCode ValData
-> VS (JavaCode ValData)
jCast' Double String _ v :: 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' Float String _ v :: 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' _ _ t :: JavaCode TypeData
t v :: JavaCode ValData
v = VSType JavaCode -> Doc -> SValue JavaCode
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal (JavaCode TypeData -> StateT ValueState Identity (JavaCode TypeData)
forall a s. a -> State s a
toState JavaCode TypeData
t) (Doc -> Doc -> Doc
R.castObj (Doc -> Doc
R.cast (JavaCode (Type JavaCode) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' JavaCode TypeData
JavaCode (Type JavaCode)
t))
          (JavaCode (Value JavaCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value JavaCode ValData
JavaCode (Value JavaCode)
v))

jConstDecDef :: (RenderSym r) => SVariable r -> SValue r -> MSStatement r
jConstDecDef :: SVariable r -> SValue r -> MSStatement r
jConstDecDef v' :: SVariable r
v' def' :: SValue r
def' = do
  r (Variable r)
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
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 (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
v'
  r (Value r)
def <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
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
Lens' MethodState ValueState
lensMStoVS SValue r
def'
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r) -> Doc -> MSStatement r
forall a b. (a -> b) -> a -> b
$ Doc
jFinal Doc -> Doc -> Doc
<+> r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' (r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType r (Variable r)
v) Doc -> Doc -> Doc
<+> 
    r (Variable r) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable r (Variable r)
v Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
def

jFuncDecDef :: (RenderSym r) => SVariable r -> [SVariable r] -> MSBody r ->
  MSStatement r
jFuncDecDef :: SVariable r -> [SVariable r] -> MSBody r -> MSStatement r
jFuncDecDef v :: SVariable r
v ps :: [SVariable r]
ps bod :: MSBody r
bod = do
  r (Variable r)
vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
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 (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
v
  [r (Variable r)]
pms <- (SVariable r -> StateT MethodState Identity (r (Variable r)))
-> [SVariable r] -> StateT MethodState Identity [r (Variable r)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
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 (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS) [SVariable r]
ps
  r (Body r)
b <- MSBody r
bod
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r) -> Doc -> MSStatement r
forall a b. (a -> b) -> a -> b
$ r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' (r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType r (Variable r)
vr) Doc -> Doc -> Doc
<+> r (Variable r) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable r (Variable r)
vr Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+>
    Doc -> Doc
parens ([r (Variable r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Variable r)] -> Doc
variableList [r (Variable r)]
pms) Doc -> Doc -> Doc
<+> Doc
jLambdaSep Doc -> Doc -> Doc
<+> Doc
bodyStart Doc -> Doc -> Doc
$$ Doc -> Doc
indent (r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
b)
    Doc -> Doc -> Doc
$$ Doc
bodyEnd

jThrowDoc :: (RenderSym r) => r (Value r) -> Doc
jThrowDoc :: r (Value r) -> Doc
jThrowDoc errMsg :: 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 :: (RenderSym r) => r (Body r) -> r (Body r) -> Doc
jTryCatch :: r (Body r) -> r (Body r) -> Doc
jTryCatch tb :: r (Body r)
tb cb :: 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 "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]

jOut :: (RenderSym r) => Bool -> Maybe (SValue r) -> SValue r -> SValue r -> 
  MSStatement r
jOut :: Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
jOut newLn :: Bool
newLn f :: Maybe (SValue r)
f printFn :: SValue r
printFn v :: SValue r
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
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
Lens' MethodState ValueState
lensMStoVS SValue r
v StateT MethodState Identity (r (Value r))
-> (r (Value r) -> MSStatement r) -> MSStatement r
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> MSStatement r
jOut' (CodeType -> MSStatement r)
-> (r (Value r) -> CodeType) -> r (Value r) -> MSStatement r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (r (Type r) -> CodeType)
-> (r (Value r) -> r (Type r)) -> r (Value r) -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Value r) -> r (Type r)
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType
  where jOut' :: CodeType -> MSStatement r
jOut' (List (Object _)) = Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
forall (r :: * -> *).
RenderSym r =>
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 _) = Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement 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' _ = Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
forall (r :: * -> *).
RenderSym r =>
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 inFn :: 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 :: * -> *).
FunctionSym 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 vr :: SVariable JavaCode
vr inFn :: SValue JavaCode
inFn = do
  JavaCode VarData
v <- State ValueState (JavaCode VarData)
SVariable JavaCode
vr
  let jInput' :: CodeType -> VS (JavaCode ValData)
jInput' Integer = SValue JavaCode -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode
jParseIntFunc (SValue JavaCode -> VS (JavaCode ValData))
-> SValue JavaCode -> VS (JavaCode ValData)
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' Float = SValue JavaCode -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode
jParseFloatFunc (SValue JavaCode -> VS (JavaCode ValData))
-> SValue JavaCode -> VS (JavaCode ValData)
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' Double = SValue JavaCode -> VS (JavaCode ValData)
SValue JavaCode -> SValue JavaCode
jParseDblFunc (SValue JavaCode -> VS (JavaCode ValData))
-> SValue JavaCode -> VS (JavaCode ValData)
forall a b. (a -> b) -> a -> b
$ SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' Boolean = SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextBoolFunc
      jInput' String = SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextLineFunc
      jInput' Char = (SValue JavaCode
inFn SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jNextFunc) SValue JavaCode -> VSFunction JavaCode -> SValue JavaCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction JavaCode
jCharAtFunc
      jInput' _ = String -> VS (JavaCode ValData)
forall a. HasCallStack => String -> a
error "Attempt to read value of unreadable type"
  CodeType -> VS (JavaCode ValData)
jInput' (JavaCode (Type JavaCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (JavaCode (Type JavaCode) -> CodeType)
-> JavaCode (Type JavaCode) -> CodeType
forall a b. (a -> b) -> a -> b
$ JavaCode (Variable JavaCode) -> JavaCode (Type JavaCode)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType JavaCode VarData
JavaCode (Variable JavaCode)
v)

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

jOpenFileWorA :: (RenderSym r) => SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA :: SValue r -> VSType r -> SValue r -> SValue r
jOpenFileWorA n :: SValue r
n t :: VSType r
t wa :: SValue r
wa = PosCtorCall r
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj VSType r
t [PosCtorCall r
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj VSType r
forall (r :: * -> *). RenderSym r => VSType r
jFileWriterType [PosCtorCall r
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj VSType r
forall (r :: * -> *). RenderSym r => VSType r
jFileType [SValue r
n], 
  SValue r
wa]]

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

jMethod :: (RenderSym r) => Label -> [String] -> r (Scope r) -> r (Permanence r)
  -> r (Type r) -> [r (Parameter r)] -> r (Body r) -> Doc
jMethod :: String
-> [String]
-> r (Scope r)
-> r (Permanence r)
-> r (Type r)
-> [r (Parameter r)]
-> r (Body r)
-> Doc
jMethod n :: String
n es :: [String]
es s :: r (Scope r)
s p :: r (Permanence r)
p t :: r (Type r)
t ps :: [r (Parameter r)]
ps b :: r (Body r)
b = [Doc] -> Doc
vcat [
  r (Scope r) -> Doc
forall (r :: * -> *). ScopeElim r => r (Scope r) -> Doc
RC.scope r (Scope r)
s Doc -> Doc -> Doc
<+> r (Permanence r) -> Doc
forall (r :: * -> *). PermElim r => r (Permanence r) -> Doc
RC.perm r (Permanence r)
p Doc -> Doc -> Doc
<+> r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' r (Type r)
t Doc -> Doc -> Doc
<+> String -> Doc
text String
n Doc -> Doc -> Doc
<> 
    Doc -> Doc
parens ([r (Parameter r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Parameter r)] -> Doc
parameterList [r (Parameter r)]
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
$ r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
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 "outputs" VSType JavaCode
jArrayType

jAssignFromArray :: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray :: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray _ [] = []
jAssignFromArray c :: Integer
c (v :: SVariable JavaCode
v:vs :: [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)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
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
$ Integer -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
Integer -> SVariable r -> SVariable r
arrayElem Integer
c SVariable JavaCode
outputs)) State MethodState (JavaCode (Doc, Terminator))
-> [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (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
+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 f :: String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f n :: String
n ins :: [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 f :: String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f n :: String
n ins :: [SValue JavaCode]
ins [out :: 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)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
out) 
  [SValue JavaCode]
ins
jInOutCall f :: String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f n :: String
n ins :: [SValue JavaCode]
ins [] [out :: 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)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
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 f :: String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f n :: String
n ins :: [SValue JavaCode]
ins outs :: [SVariable JavaCode]
outs both :: [SVariable JavaCode]
both = [State ValueState (JavaCode VarData)]
-> State MethodState (JavaCode (Doc, Terminator))
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)]
-> State MethodState (JavaCode (Doc, Terminator))
fCall [x :: 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 -> State MethodState (JavaCode (Doc, Terminator)))
-> SValue JavaCode
-> State MethodState (JavaCode (Doc, Terminator))
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)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (JavaCode VarData)
x) 
          ((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)
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
both [VS (JavaCode ValData)]
-> [VS (JavaCode ValData)] -> [VS (JavaCode ValData)]
forall a. [a] -> [a] -> [a]
++ [VS (JavaCode ValData)]
[SValue JavaCode]
ins)
        fCall xs :: [State ValueState (JavaCode VarData)]
xs = MS Bool
isOutputsDeclared MS Bool
-> (Bool -> State MethodState (JavaCode (Doc, Terminator)))
-> State MethodState (JavaCode (Doc, Terminator))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\odec :: Bool
odec -> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
setOutputsDeclared StateT MethodState Identity ()
-> State MethodState (JavaCode (Doc, Terminator))
-> State MethodState (JavaCode (Doc, Terminator))
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 State ValueState (JavaCode VarData)
-> VS (JavaCode ValData)
-> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign else State ValueState (JavaCode VarData)
-> VS (JavaCode ValData)
-> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> SValue r -> MSStatement r
varDecDef) State ValueState (JavaCode VarData)
SVariable JavaCode
outputs 
          (String -> VSType JavaCode -> [SValue JavaCode] -> SValue JavaCode
f String
n VSType JavaCode
jArrayType ((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)
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
both [VS (JavaCode ValData)]
-> [VS (JavaCode ValData)] -> [VS (JavaCode ValData)]
forall a. [a] -> [a] -> [a]
++ [VS (JavaCode ValData)]
[SValue JavaCode]
ins)) State MethodState (JavaCode (Doc, Terminator))
-> [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SVariable JavaCode] -> [MSStatement JavaCode]
jAssignFromArray 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 f :: VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ins :: [SVariable JavaCode]
ins [] [] b :: MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f VSType JavaCode
forall (r :: * -> *). TypeSym r => VSType r
void ((State ValueState (JavaCode VarData)
 -> State MethodState (JavaCode ParamData))
-> [State ValueState (JavaCode VarData)]
-> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData)
-> State MethodState (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
ins) MSBody JavaCode
b
jInOut f :: VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ins :: [SVariable JavaCode]
ins [v :: SVariable JavaCode
v] [] b :: MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
v) ((State ValueState (JavaCode VarData)
 -> State MethodState (JavaCode ParamData))
-> [State ValueState (JavaCode VarData)]
-> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData)
-> State MethodState (JavaCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [State ValueState (JavaCode VarData)]
[SVariable JavaCode]
ins) 
  ((JavaCode (Doc, Terminator)
 -> JavaCode Doc -> JavaCode (Doc, Terminator) -> JavaCode Doc)
-> State MethodState (JavaCode (Doc, Terminator))
-> State MethodState (JavaCode Doc)
-> State MethodState (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 -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> MSStatement r
varDec SVariable JavaCode
v) State MethodState (JavaCode Doc)
MSBody JavaCode
b (SValue JavaCode -> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> State MethodState (JavaCode (Doc, Terminator)))
-> SValue JavaCode
-> State MethodState (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ 
  SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut f :: VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ins :: [SVariable JavaCode]
ins [] [v :: SVariable JavaCode
v] b :: MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ((JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (JavaCode VarData)
SVariable JavaCode
v) 
  ((State ValueState (JavaCode VarData)
 -> State MethodState (JavaCode ParamData))
-> [State ValueState (JavaCode VarData)]
-> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData)
-> State MethodState (JavaCode ParamData)
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)
-> State MethodState (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 -> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> State MethodState (JavaCode (Doc, Terminator)))
-> SValue JavaCode
-> State MethodState (JavaCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SVariable JavaCode -> SValue JavaCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable JavaCode
v))
jInOut f :: VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ins :: [SVariable JavaCode]
ins outs :: [SVariable JavaCode]
outs both :: [SVariable JavaCode]
both b :: MSBody JavaCode
b = VSType JavaCode
-> [MSParameter JavaCode] -> MSBody JavaCode -> SMethod JavaCode
f ([State ValueState (JavaCode VarData)]
-> StateT ValueState Identity (JavaCode TypeData)
returnTp [State ValueState (JavaCode VarData)]
rets)
  ((State ValueState (JavaCode VarData)
 -> State MethodState (JavaCode ParamData))
-> [State ValueState (JavaCode VarData)]
-> [State MethodState (JavaCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData)
-> State MethodState (JavaCode ParamData)
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)
-> State MethodState (JavaCode (Doc, Terminator))
-> State MethodState (JavaCode Doc)
-> State MethodState (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) State MethodState (JavaCode (Doc, Terminator))
MSStatement JavaCode
decls 
  State MethodState (JavaCode Doc)
MSBody JavaCode
b ([State ValueState (JavaCode VarData)]
-> State MethodState (JavaCode (Doc, Terminator))
returnSt [State ValueState (JavaCode VarData)]
rets))
  where returnTp :: [State ValueState (JavaCode VarData)]
-> StateT ValueState Identity (JavaCode TypeData)
returnTp [x :: State ValueState (JavaCode VarData)
x] = (JavaCode VarData -> JavaCode TypeData)
-> State ValueState (JavaCode VarData)
-> StateT ValueState Identity (JavaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JavaCode VarData -> JavaCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (JavaCode VarData)
x
        returnTp _ = StateT ValueState Identity (JavaCode TypeData)
VSType JavaCode
jArrayType
        returnSt :: [State ValueState (JavaCode VarData)]
-> State MethodState (JavaCode (Doc, Terminator))
returnSt [x :: State ValueState (JavaCode VarData)
x] = SValue JavaCode -> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue JavaCode -> State MethodState (JavaCode (Doc, Terminator)))
-> SValue JavaCode
-> State MethodState (JavaCode (Doc, Terminator))
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 _ = [MSStatement JavaCode] -> MSStatement JavaCode
forall (r :: * -> *).
StatementSym r =>
[MSStatement r] -> MSStatement r
multi (Integer -> SVariable JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
DeclStatement r =>
Integer -> SVariable r -> 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 (t :: * -> *) a. Foldable t => t a -> Int
length [State ValueState (JavaCode VarData)]
rets) SVariable JavaCode
outputs
          State MethodState (JavaCode (Doc, Terminator))
-> [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (JavaCode (Doc, Terminator))]
forall a. a -> [a] -> [a]
: Integer -> [SValue JavaCode] -> [MSStatement JavaCode]
assignArray 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)
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf [State ValueState (JavaCode VarData)]
rets)
          [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (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 _ [] = []
        assignArray c :: Integer
c (v :: SValue JavaCode
v:vs :: [SValue JavaCode]
vs) = (Integer -> SVariable JavaCode -> SVariable JavaCode
forall (r :: * -> *).
VariableSym r =>
Integer -> SVariable r -> SVariable r
arrayElem Integer
c SVariable JavaCode
outputs SVariable JavaCode -> SValue JavaCode -> MSStatement JavaCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= SValue JavaCode
v) State MethodState (JavaCode (Doc, Terminator))
-> [State MethodState (JavaCode (Doc, Terminator))]
-> [State MethodState (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
+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
$ (State ValueState (JavaCode VarData)
 -> State MethodState (JavaCode (Doc, Terminator)))
-> [State ValueState (JavaCode VarData)]
-> [State MethodState (JavaCode (Doc, Terminator))]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (JavaCode VarData)
-> State MethodState (JavaCode (Doc, Terminator))
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> MSStatement r
varDec [State ValueState (JavaCode VarData)]
[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 :: (RenderSym 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)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
jDocInOut f :: [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f desc :: String
desc is :: [(String, SVariable r)]
is [] [] b :: MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
RenderSym 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 f :: [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f desc :: String
desc is :: [(String, SVariable r)]
is [o :: (String, SVariable r)
o] [] b :: MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
RenderSym 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 f :: [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f desc :: String
desc is :: [(String, SVariable r)]
is [] [both :: (String, SVariable r)
both] b :: MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
RenderSym 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 f :: [SVariable r]
-> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r
f desc :: String
desc is :: [(String, SVariable r)]
is os :: [(String, SVariable r)]
os bs :: [(String, SVariable r)]
bs b :: MSBody r
b = FuncDocRenderer
-> String -> [String] -> [String] -> SMethod r -> SMethod r
forall (r :: * -> *).
RenderSym 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 = "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 :: (RenderSym r) => Label -> Maybe Label -> [CSStateVar r] -> 
  [SMethod r] -> SClass r
jExtraClass :: String -> Maybe String -> [CSStateVar r] -> [SMethod r] -> SClass r
jExtraClass n :: String
n = String
-> r (Scope r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> SClass r
forall (r :: * -> *).
RenderClass r =>
String
-> r (Scope r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> SClass r
intClass String
n (ScopeTag -> Doc -> r (Scope r)
forall (r :: * -> *).
RenderScope r =>
ScopeTag -> Doc -> r (Scope r)
scopeFromData ScopeTag
Priv Doc
empty) (r Doc -> [CSStateVar r] -> [SMethod r] -> SClass r)
-> (Maybe String -> r Doc)
-> Maybe String
-> [CSStateVar r]
-> [SMethod r]
-> SClass 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 n :: String
n = do
  String
cm <- LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
-> StateT FileState Identity String
-> StateT ValueState Identity String
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
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 :: (RenderSym r) => VSType r -> 
  (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod :: VSType r -> (VSType r -> SValue r) -> SValue r
addConstructorCallExcsCurrMod ot :: VSType r
ot f :: VSType r -> SValue r
f = do
  r (Type r)
t <- VSType r
ot
  String
cm <- LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
-> StateT FileState Identity String
-> StateT ValueState Identity String
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
Lens' ValueState FileState
lensVStoFS StateT FileState Identity String
getModuleName
  Map QualifiedName [ExceptionType]
mem <- VS (Map QualifiedName [ExceptionType])
getMethodExcMap
  let tp :: String
tp = r (Type r) -> String
forall (r :: * -> *). TypeElim r => r (Type r) -> String
getTypeString r (Type r)
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 (Type r) -> VSType r
forall (m :: * -> *) a. Monad m => a -> m a
return r (Type r)
t)