{- |
Module      :  ./CSL/Keywords.hs
Description :  String constants for CSL keywords to be used for parsing
  and printing
Copyright   :  Dominik Dietrich, DFKI Bremen 2010
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Dominik.Dietrich@dfki.de
Stability   :  provisional
Portability :  portable

String constants for keywords to be used for parsing and reduce expressions

-}

module CSL.Keywords where

-- commands

algebraicS :: String
algebraicS :: String
algebraicS = "algebraic"

antisymmetricS :: String
antisymmetricS :: String
antisymmetricS = "antisymmetric"

arrayS :: String
arrayS :: String
arrayS = "array"

clearS :: String
clearS :: String
clearS = "clear"

byeS :: String
byeS :: String
byeS = "bye"

clearrulesS :: String
clearrulesS :: String
clearrulesS = "clearrules"

commentS :: String
commentS :: String
commentS = "comment"

contS :: String
contS :: String
contS = "cont"

decomposeS :: String
decomposeS :: String
decomposeS = "decompose"

defineS :: String
defineS :: String
defineS = "define"

dependS :: String
dependS :: String
dependS = "depends"

displayS :: String
displayS :: String
displayS = "display"

edS :: String
edS :: String
edS = "ed"

editdefS :: String
editdefS :: String
editdefS = "editdef"

endS :: String
endS :: String
endS = "end"

evenS :: String
evenS :: String
evenS = "even"

factorS :: String
factorS :: String
factorS = "factor"

forS :: String
forS :: String
forS = "for"

forallS :: String
forallS :: String
forallS = "forall"

foreachS :: String
foreachS :: String
foreachS = "foreach"

goS :: String
goS :: String
goS = "go"

gotoS :: String
gotoS :: String
gotoS = "goto"

ifS :: String
ifS :: String
ifS = "if"

inS :: String
inS :: String
inS = "in"

indexS :: String
indexS :: String
indexS = "index"

infixS :: String
infixS :: String
infixS = "infix"

inputS :: String
inputS :: String
inputS = "input"

integerS :: String
integerS :: String
integerS = "integer"

korderS :: String
korderS :: String
korderS = "korder"

letS :: String
letS :: String
letS = "let"

linearS :: String
linearS :: String
linearS = "linear"

lispS :: String
lispS :: String
lispS = "lisp"

listargpS :: String
listargpS :: String
listargpS = "lispargp"

loadS :: String
loadS :: String
loadS = "load"

loadpackageS :: String
loadpackageS :: String
loadpackageS = "loadpackage"

massS :: String
massS :: String
massS = "mass"

matchS :: String
matchS :: String
matchS = "match"

matrixS :: String
matrixS :: String
matrixS = "matrix"

mshellS :: String
mshellS :: String
mshellS = "mshell"

nodependS :: String
nodependS :: String
nodependS = "nodepend"

noncomS :: String
noncomS :: String
noncomS = "nocom"

nonzeroS :: String
nonzeroS :: String
nonzeroS = "nonzero"

nospurS :: String
nospurS :: String
nospurS = "nospur"

oddS :: String
oddS :: String
oddS = "odd"

offS :: String
offS :: String
offS = "off"

onS :: String
onS :: String
onS = "on"

operatorS :: String
operatorS :: String
operatorS = "operator"

orderS :: String
orderS :: String
orderS = "order"

outS :: String
outS :: String
outS = "out"

pauseS :: String
pauseS :: String
pauseS = "pause"

precedenceS :: String
precedenceS :: String
precedenceS = "precedence"

printprecisionS :: String
printprecisionS :: String
printprecisionS = "printprecision"

procedureS :: String
procedureS :: String
procedureS = "procedure"

quitS :: String
quitS :: String
quitS = "quit"

realS :: String
realS :: String
realS = "real"

remfacS :: String
remfacS :: String
remfacS = "remfac"

remindS :: String
remindS :: String
remindS = "remind"

retryS :: String
retryS :: String
retryS = "retry"

returnS :: String
returnS :: String
returnS = "return"

saveasS :: String
saveasS :: String
saveasS = "saveas"

scalarS :: String
scalarS :: String
scalarS = "scalar"

setmodS :: String
setmodS :: String
setmodS = "setmod"

shareS :: String
shareS :: String
shareS = "share"

showtimeS :: String
showtimeS :: String
showtimeS = "showtime"

shutS :: String
shutS :: String
shutS = "shut"

spurS :: String
spurS :: String
spurS = "spur"

symbolicS :: String
symbolicS :: String
symbolicS = "symbolic"

symmetricS :: String
symmetricS :: String
symmetricS = "symmetric"

vecdimS :: String
vecdimS :: String
vecdimS = "vecdim"

vectorS :: String
vectorS :: String
vectorS = "vector"

wheightS :: String
wheightS :: String
wheightS = "wheight"

writeS :: String
writeS :: String
writeS = "write"

wtlevelS :: String
wtlevelS :: String
wtlevelS = "wtlevel"

commandKeywords :: [String]
commandKeywords :: [String]
commandKeywords = [String
algebraicS, String
antisymmetricS, String
arrayS, String
byeS, String
clearS, String
clearrulesS, String
commentS, String
contS, String
decomposeS, String
defineS, String
dependS, String
displayS, String
edS, String
editdefS, String
endS, String
evenS, String
factorS, String
forS, String
forallS, String
foreachS, String
goS, String
gotoS, String
ifS, String
inS, String
indexS, String
infixS, String
inputS, String
integerS, String
korderS, String
letS, String
linearS, String
lispS, String
listargpS, String
loadS, String
loadpackageS, String
massS, String
matchS, String
matrixS, String
mshellS, String
nodependS, String
noncomS, String
nonzeroS, String
nospurS, String
oddS, String
offS, String
onS, String
operatorS, String
orderS, String
outS, String
pauseS, String
precedenceS, String
printprecisionS, String
procedureS, String
quitS, String
realS, String
remfacS, String
remindS, String
retryS, String
returnS, String
saveasS, String
scalarS, String
setmodS, String
shareS, String
showtimeS, String
shutS, String
spurS, String
symbolicS, String
symmetricS, String
vecdimS, String
vectorS, String
wheightS, String
writeS, String
wtlevelS]

-- boolean operators

evenpS :: String
evenpS :: String
evenpS = "even"

fixpS :: String
fixpS :: String
fixpS = "fixp"

freeofS :: String
freeofS :: String
freeofS = "freeof"

numberpS :: String
numberpS :: String
numberpS = "numperp"

ordpS :: String
ordpS :: String
ordpS = "ordp"

primepS :: String
primepS :: String
primepS = "primep"

convergenceS :: String
convergenceS :: String
convergenceS = "convergence"

booleanKeywords :: [String]
booleanKeywords :: [String]
booleanKeywords = [ String
evenpS, String
fixpS, String
freeofS, String
numberpS, String
ordpS, String
primepS
                  , String
convergenceS]


-- infix operators
sym_assignS :: String
sym_assignS :: String
sym_assignS = ":="

sym_equalS :: String
sym_equalS :: String
sym_equalS = "="


sym_lessS :: String
sym_lessS :: String
sym_lessS = "<"

sym_greaterS :: String
sym_greaterS :: String
sym_greaterS = ">"

sym_geqS :: String
sym_geqS :: String
sym_geqS = ">="

sym_leqS :: String
sym_leqS :: String
sym_leqS = "<="

sym_plusS :: String
sym_plusS :: String
sym_plusS = "+"

sym_minusS :: String
sym_minusS :: String
sym_minusS = "-"

sym_expS :: String
sym_expS :: String
sym_expS = "^"

sym_divS :: String
sym_divS :: String
sym_divS = "/"

sym_expmulS :: String
sym_expmulS :: String
sym_expmulS = "**"

orS :: String
orS :: String
orS = "or"

andS :: String
andS :: String
andS = "and"

memberS :: String
memberS :: String
memberS = "member"

memqS :: String
memqS :: String
memqS = "memq"

equalS :: String
equalS :: String
equalS = "equal"

neqS :: String
neqS :: String
neqS = "neq"

eqS :: String
eqS :: String
eqS = "eq"

geqS :: String
geqS :: String
geqS = "geq"

greaterpS :: String
greaterpS :: String
greaterpS = "greaterp"

leqS :: String
leqS :: String
leqS = "leq"

lesspS :: String
lesspS :: String
lesspS = "lessp"

plusS :: String
plusS :: String
plusS = "plus"

differenceS :: String
differenceS :: String
differenceS = "difference"

minusS :: String
minusS :: String
minusS = "minus"

timesS :: String
timesS :: String
timesS = "times"

quotientS :: String
quotientS :: String
quotientS = "quotient"

exptS :: String
exptS :: String
exptS = "expt"

consS :: String
consS :: String
consS = "cons"


infixKeywords :: [String]
infixKeywords :: [String]
infixKeywords = [String
sym_assignS, String
sym_equalS, String
sym_lessS, String
sym_greaterS, String
sym_geqS, String
sym_leqS, String
sym_plusS, String
sym_minusS, String
sym_expS, String
sym_divS, String
sym_expmulS, String
sym_expS, String
orS, String
andS, String
memberS, String
memqS, String
equalS, String
neqS, String
eqS, String
geqS, String
greaterpS, String
leqS, String
lesspS, String
plusS, String
differenceS, String
minusS, String
timesS, String
quotientS, String
exptS, String
consS]


-- numerical operators
absS :: String
absS :: String
absS = "abs"

acosS :: String
acosS :: String
acosS = "acos"

acoshS :: String
acoshS :: String
acoshS = "acosh"

acothS :: String
acothS :: String
acothS = "actoh"

acscS :: String
acscS :: String
acscS = "acsc"

acschS :: String
acschS :: String
acschS = "acsch"

asecS :: String
asecS :: String
asecS = "asec"

asechS :: String
asechS :: String
asechS = "asech"

asinS :: String
asinS :: String
asinS = "asin"

asinhS :: String
asinhS :: String
asinhS = "asinh"

atanS :: String
atanS :: String
atanS = "atan"

atanhS :: String
atanhS :: String
atanhS = "atanh"

atan2S :: String
atan2S :: String
atan2S = "atan2"

cosS :: String
cosS :: String
cosS = "cos"

coshS :: String
coshS :: String
coshS = "cosh"

cotS :: String
cotS :: String
cotS = "cot"

cothS :: String
cothS :: String
cothS = "coth"

cscS :: String
cscS :: String
cscS = "csc"

cschS :: String
cschS :: String
cschS = "csch"

expS :: String
expS :: String
expS = "exp"

factorialS :: String
factorialS :: String
factorialS = "factorial"

fixS :: String
fixS :: String
fixS = "fix"

floorS :: String
floorS :: String
floorS = "floor"

hypotS :: String
hypotS :: String
hypotS = "hypot"

lnS :: String
lnS :: String
lnS = "ln"

logS :: String
logS :: String
logS = "log"

logbS :: String
logbS :: String
logbS = "logb"

log10S :: String
log10S :: String
log10S = "log10"

nextprimeS :: String
nextprimeS :: String
nextprimeS = "nextprime"

roundS :: String
roundS :: String
roundS = "round"

secS :: String
secS :: String
secS = "sec"

sechS :: String
sechS :: String
sechS = "sech"

sinS :: String
sinS :: String
sinS = "sin"

sinhS :: String
sinhS :: String
sinhS = "sinh"

sqrtS :: String
sqrtS :: String
sqrtS = "sqrt"

tanS :: String
tanS :: String
tanS = "tan"

tanhS :: String
tanhS :: String
tanhS = "tanh"

numericalKeywords :: [String]
numericalKeywords :: [String]
numericalKeywords = [String
absS, String
acosS, String
acoshS, String
acothS, String
acscS, String
acschS, String
asecS, String
asechS, String
asinS, String
asinhS, String
atanS, String
atanhS, String
atan2S, String
cosS, String
coshS, String
cotS, String
cothS, String
cscS, String
cschS, String
expS, String
factorialS, String
fixS, String
floorS, String
hypotS, String
lnS, String
logS, String
logbS, String
log10S, String
nextprimeS, String
roundS, String
secS, String
sechS, String
sinS, String
sinhS, String
sqrtS, String
tanS, String
tanhS]


-- prefix operators
appendS :: String
appendS :: String
appendS = "append"

arglengthS :: String
arglengthS :: String
arglengthS = " arglenght"

ceilingS :: String
ceilingS :: String
ceilingS = "ceiling"

coeffS :: String
coeffS :: String
coeffS = "coeff"

coeffnS :: String
coeffnS :: String
coeffnS = "coeffn"

cofactorS :: String
cofactorS :: String
cofactorS = "cofactor"

conjS :: String
conjS :: String
conjS = "conj"

degS :: String
degS :: String
degS = "deg"

denS :: String
denS :: String
denS = "den"

detS :: String
detS :: String
detS = "det"

defS :: String
defS :: String
defS = "def"

dilogS :: String
dilogS :: String
dilogS = "dilog"

eiS :: String
eiS :: String
eiS = "ei"

epsS :: String
epsS :: String
epsS = "eps"

erfS :: String
erfS :: String
erfS = "erf"

factorizeS :: String
factorizeS :: String
factorizeS = "factorize"

firstS :: String
firstS :: String
firstS = "first"

gcdS :: String
gcdS :: String
gcdS = "gcd"


gS :: String
gS :: String
gS = "g"

impartS :: String
impartS :: String
impartS = "impart"

intS :: String
intS :: String
intS = "int"

interpolS :: String
interpolS :: String
interpolS = "interpol"

lcmS :: String
lcmS :: String
lcmS = "lcm"

lcofS :: String
lcofS :: String
lcofS = "lcof"

lengthS :: String
lengthS :: String
lengthS = "length"

lhsS :: String
lhsS :: String
lhsS = "lhs"

linelengthS :: String
linelengthS :: String
linelengthS = "linelength"

lltermS :: String
lltermS :: String
lltermS = "llterm"

mainvarS :: String
mainvarS :: String
mainvarS = "mainvar"

matS :: String
matS :: String
matS = "mat"

mateigenS :: String
mateigenS :: String
mateigenS = "mateigen"

maxS :: String
maxS :: String
maxS = "max"

minS :: String
minS :: String
minS = "min"

mkidS :: String
mkidS :: String
mkidS = "mkid"

nullspaceS :: String
nullspaceS :: String
nullspaceS = "nullspace"

numS :: String
numS :: String
numS = "num"

partS :: String
partS :: String
partS = "part"

pfS :: String
pfS :: String
pfS = "pf"

precisionS :: String
precisionS :: String
precisionS = "precision"

prodS :: String
prodS :: String
prodS = "prod"

randomS :: String
randomS :: String
randomS = "random"

randomnewseedS :: String
randomnewseedS :: String
randomnewseedS = "randomnewseed"

rankS :: String
rankS :: String
rankS = "rank"

rederrS :: String
rederrS :: String
rederrS = "rederr"

reductS :: String
reductS :: String
reductS = "reduct"

remainderS :: String
remainderS :: String
remainderS = "remainder"

repartS :: String
repartS :: String
repartS = "repart"

restS :: String
restS :: String
restS = "rest"

resultantS :: String
resultantS :: String
resultantS = "resultant"

reverseS :: String
reverseS :: String
reverseS = "reverse"

rhsS :: String
rhsS :: String
rhsS = "rhs"

secondS :: String
secondS :: String
secondS = "second"

setS :: String
setS :: String
setS = "set"

showrulesS :: String
showrulesS :: String
showrulesS = "showrules"

signS :: String
signS :: String
signS = "sign"

solveS :: String
solveS :: String
solveS = "solve"

structrS :: String
structrS :: String
structrS = "structr"

subS :: String
subS :: String
subS = "sub"

sumS :: String
sumS :: String
sumS = "sum"

thirdS :: String
thirdS :: String
thirdS = "third"

tpS :: String
tpS :: String
tpS = "tp"

traceS :: String
traceS :: String
traceS = "trace"

varnameS :: String
varnameS :: String
varnameS = "varname"

prefixKeywords :: [String]
prefixKeywords :: [String]
prefixKeywords = [String
appendS, String
arglengthS, String
ceilingS, String
coeffS, String
coeffnS, String
cofactorS, String
conjS, String
degS, String
denS, String
detS, String
defS, String
dilogS, String
eiS, String
epsS, String
erfS, String
factorizeS, String
firstS, String
gcdS, String
gS, String
impartS, String
intS, String
interpolS, String
lcmS, String
lcofS, String
lengthS, String
lhsS, String
linelengthS, String
lltermS, String
mainvarS, String
matS, String
mateigenS, String
maxS, String
minS, String
mkidS, String
nullspaceS, String
numS, String
partS, String
pfS, String
precisionS, String
prodS, String
randomS, String
randomnewseedS, String
rankS, String
rederrS, String
reductS, String
remainderS, String
repartS, String
restS, String
resultantS, String
reverseS, String
rhsS, String
secondS, String
setS, String
showrulesS, String
signS, String
solveS, String
structrS, String
subS, String
sumS, String
thirdS, String
tpS, String
traceS, String
varnameS]


-- reserved variables
cardnoS :: String
cardnoS :: String
cardnoS = "cardno"

eS :: String
eS :: String
eS = "e"

evalmodeS :: String
evalmodeS :: String
evalmodeS = "evalmode"

fortwidthS :: String
fortwidthS :: String
fortwidthS = "fortwidth"

highpowS :: String
highpowS :: String
highpowS = "highpow"

iS :: String
iS :: String
iS = "i"

infinityS :: String
infinityS :: String
infinityS = "infinity"

kexlamS :: String
kexlamS :: String
kexlamS = "k!*"

lowpowS :: String
lowpowS :: String
lowpowS = "lowpow"

nilS :: String
nilS :: String
nilS = "nil"

piS :: String
piS :: String
piS = "pi"

rootmultS :: String
rootmultS :: String
rootmultS = "rootmult"

tS :: String
tS :: String
tS = "t"

varKeywords :: [String]
varKeywords :: [String]
varKeywords = [String
cardnoS, String
eS, String
evalmodeS, String
fortwidthS, String
highpowS, String
iS, String
infinityS, String
kexlamS, String
lowpowS, String
nilS, String
piS, String
rootmultS, String
tS]


-- switches

adjprecS :: String
adjprecS :: String
adjprecS = "adjprec"

algintS :: String
algintS :: String
algintS = "algint"

allbranchS :: String
allbranchS :: String
allbranchS = "allbranch"

allfacS :: String
allfacS :: String
allfacS = "allfac"

balancemodS :: String
balancemodS :: String
balancemodS = "balancemod"

bfspaceS :: String
bfspaceS :: String
bfspaceS = "bfspace"

combineexptS :: String
combineexptS :: String
combineexptS = "comineexpt"

defnS :: String
defnS :: String
defnS = "defn"

demoS :: String
demoS :: String
demoS = "demo"

divS :: String
divS :: String
divS = "div"

echoS :: String
echoS :: String
echoS = "echo"

errcontS :: String
errcontS :: String
errcontS = "errcont"

evallhseqpS :: String
evallhseqpS :: String
evallhseqpS = "evallhseqp"


expandlogsS :: String
expandlogsS :: String
expandlogsS = "expandlogs"

ezgcdS :: String
ezgcdS :: String
ezgcdS = "ezgcd"

fortS :: String
fortS :: String
fortS = "fort"

fullrootsS :: String
fullrootsS :: String
fullrootsS = "fullroots"

ifactorS :: String
ifactorS :: String
ifactorS = "ifactor"


intstrS :: String
intstrS :: String
intstrS = "intstr"


listS :: String
listS :: String
listS = "list"

listargsS :: String
listargsS :: String
listargsS = "listargs"

mcdS :: String
mcdS :: String
mcdS = "mcd"

modularS :: String
modularS :: String
modularS = "modular"

msgS :: String
msgS :: String
msgS = "msg"

multiplicitiesS :: String
multiplicitiesS :: String
multiplicitiesS = "multiplicities"

natS :: String
natS :: String
natS = "nat"

neroS :: String
neroS :: String
neroS = "nero"

nosplitS :: String
nosplitS :: String
nosplitS = "nosplit"

outputS :: String
outputS :: String
outputS = "output"

periodS :: String
periodS :: String
periodS = "period"

preciseS :: String
preciseS :: String
preciseS = "precise"

pretS :: String
pretS :: String
pretS = "pret"

priS :: String
priS :: String
priS = "pri"

ratS :: String
ratS :: String
ratS = "rat"

ratargS :: String
ratargS :: String
ratargS = "ratargs"

rationalS :: String
rationalS :: String
rationalS = "rational"

rationalizeS :: String
rationalizeS :: String
rationalizeS = "rationalize"

ratrpiS :: String
ratrpiS :: String
ratrpiS = "ratrpi"

revpriS :: String
revpriS :: String
revpriS = "repvpri"

rlisp88S :: String
rlisp88S :: String
rlisp88S = "rlisp88"

roundallS :: String
roundallS :: String
roundallS = "roundall"

roundbdS :: String
roundbdS :: String
roundbdS = "roundbd"

roundedS :: String
roundedS :: String
roundedS = "rounded"

savestructrS :: String
savestructrS :: String
savestructrS = "savestructr"

solvesingularS :: String
solvesingularS :: String
solvesingularS = "solvesingular"

timeS :: String
timeS :: String
timeS = "times"

traS :: String
traS :: String
traS = "tra"

trfacS :: String
trfacS :: String
trfacS = "trafac"

trigformS :: String
trigformS :: String
trigformS = "trigform"


trintS :: String
trintS :: String
trintS = "trint"

switchKeywords :: [String]
switchKeywords :: [String]
switchKeywords = [String
adjprecS, String
algintS, String
allbranchS, String
allfacS, String
balancemodS, String
bfspaceS, String
combineexptS, String
defnS, String
demoS, String
divS, String
echoS, String
errcontS, String
evallhseqpS, String
expS, String
expandlogsS, String
ezgcdS, String
factorS, String
fortS, String
fullrootsS, String
gcdS, String
ifactorS, String
intS, String
intstrS, String
lcmS, String
listS, String
listargsS, String
mcdS, String
modularS, String
msgS, String
multiplicitiesS, String
natS, String
neroS, String
nosplitS, String
outputS, String
periodS, String
preciseS, String
pretS, String
priS, String
ratS, String
ratargS, String
rationalS, String
rationalizeS, String
ratrpiS, String
revpriS, String
rlisp88S, String
roundallS, String
roundbdS, String
roundedS, String
savestructrS, String
solvesingularS, String
timeS, String
traS, String
trfacS, String
trigformS, String
trintS]


-- others
beginS :: String
beginS :: String
beginS = "begin"

doS :: String
doS :: String
doS = "do"

exprS :: String
exprS :: String
exprS = "expr"

fexprS :: String
fexprS :: String
fexprS = "fexpr"

lambdaS :: String
lambdaS :: String
lambdaS = "lambda"

macroS :: String
macroS :: String
macroS = "macro"

productS :: String
productS :: String
productS = "product"

repeatS :: String
repeatS :: String
repeatS = "repeat"

smacroS :: String
smacroS :: String
smacroS = "scmacro"

untilS :: String
untilS :: String
untilS = "until"

whenS :: String
whenS :: String
whenS = "when"

whileS :: String
whileS :: String
whileS = "while"

wsS :: String
wsS :: String
wsS = "ws"

otherKeywords :: [String]
otherKeywords :: [String]
otherKeywords = [String
beginS, String
doS, String
exprS, String
fexprS, String
inputS, String
lambdaS, String
lispS, String
macroS, String
productS, String
repeatS, String
smacroS, String
sumS, String
untilS, String
whenS, String
whileS, String
wsS]


--
allKeywords :: [String]
allKeywords :: [String]
allKeywords = [String]
commandKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
booleanKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
infixKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
numericalKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
prefixKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
varKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
switchKeywords [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
otherKeywords