content: {- |
  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 = "algebraic"
  
  antisymmetricS :: String
  antisymmetricS = "antisymmetric"
  
  arrayS :: String
  arrayS = "array"
  
  clearS :: String
  clearS = "clear"
  
  byeS :: String
  byeS = "bye"
  
  clearrulesS :: String
  clearrulesS = "clearrules"
  
  commentS :: String
  commentS = "comment"
  
  contS :: String
  contS = "cont"
  
  decomposeS :: String
  decomposeS = "decompose"
  
  defineS :: String
  defineS = "define"
  
  dependS :: String
  dependS = "depends"
  
  displayS :: String
  displayS = "display"
  
  edS :: String
  edS = "ed"
  
  editdefS :: String
  editdefS = "editdef"
  
  endS :: String
  endS = "end"
  
  evenS :: String
  evenS = "even"
  
  factorS :: String
  factorS = "factor"
  
  forS :: String
  forS = "for"
  
  forallS :: String
  forallS = "forall"
  
  foreachS :: String
  foreachS = "foreach"
  
  goS :: String
  goS = "go"
  
  gotoS :: String
  gotoS = "goto"
  
  ifS :: String
  ifS = "if"
  
  inS :: String
  inS = "in"
  
  indexS :: String
  indexS = "index"
  
  infixS :: String
  infixS = "infix"
  
  inputS :: String
  inputS = "input"
  
  integerS :: String
  integerS = "integer"
  
  korderS :: String
  korderS = "korder"
  
  letS :: String
  letS = "let"
  
  linearS :: String
  linearS = "linear"
  
  lispS :: String
  lispS = "lisp"
  
  listargpS :: String
  listargpS = "lispargp"
  
  loadS :: String
  loadS = "load"
  
  loadpackageS :: String
  loadpackageS = "loadpackage"
  
  massS :: String
  massS = "mass"
  
  matchS :: String
  matchS = "match"
  
  matrixS :: String
  matrixS = "matrix"
  
  mshellS :: String
  mshellS = "mshell"
  
  nodependS :: String
  nodependS = "nodepend"
  
  noncomS :: String
  noncomS = "nocom"
  
  nonzeroS :: String
  nonzeroS = "nonzero"
  
  nospurS :: String
  nospurS = "nospur"
  
  oddS :: String
  oddS = "odd"
  
  offS :: String
  offS = "off"
  
  onS :: String
  onS = "on"
  
  operatorS :: String
  operatorS = "operator"
  
  orderS :: String
  orderS = "order"
  
  outS :: String
  outS = "out"
  
  pauseS :: String
  pauseS = "pause"
  
  precedenceS :: String
  precedenceS = "precedence"
  
  printprecisionS :: String
  printprecisionS = "printprecision"
  
  procedureS :: String
  procedureS = "procedure"
  
  quitS :: String
  quitS = "quit"
  
  realS :: String
  realS = "real"
  
  remfacS :: String
  remfacS = "remfac"
  
  remindS :: String
  remindS = "remind"
  
  retryS :: String
  retryS = "retry"
  
  returnS :: String
  returnS = "return"
  
  saveasS :: String
  saveasS = "saveas"
  
  scalarS :: String
  scalarS = "scalar"
  
  setmodS :: String
  setmodS = "setmod"
  
  shareS :: String
  shareS = "share"
  
  showtimeS :: String
  showtimeS = "showtime"
  
  shutS :: String
  shutS = "shut"
  
  spurS :: String
  spurS = "spur"
  
  symbolicS :: String
  symbolicS = "symbolic"
  
  symmetricS :: String
  symmetricS = "symmetric"
  
  vecdimS :: String
  vecdimS = "vecdim"
  
  vectorS :: String
  vectorS = "vector"
  
  wheightS :: String
  wheightS = "wheight"
  
  writeS :: String
  writeS = "write"
  
  wtlevelS :: String
  wtlevelS = "wtlevel"
  
  commandKeywords :: [String]
  commandKeywords = [algebraicS, antisymmetricS, arrayS, byeS, clearS, clearrulesS, commentS, contS, decomposeS, defineS, dependS, displayS, edS, editdefS, endS, evenS, factorS, forS, forallS, foreachS, goS, gotoS, ifS, inS, indexS, infixS, inputS, integerS, korderS, letS, linearS, lispS, listargpS, loadS, loadpackageS, massS, matchS, matrixS, mshellS, nodependS, noncomS, nonzeroS, nospurS, oddS, offS, onS, operatorS, orderS, outS, pauseS, precedenceS, printprecisionS, procedureS, quitS, realS, remfacS, remindS, retryS, returnS, saveasS, scalarS, setmodS, shareS, showtimeS, shutS, spurS, symbolicS, symmetricS, vecdimS, vectorS, wheightS, writeS, wtlevelS]
  
  -- boolean operators
  
  evenpS :: String
  evenpS = "even"
  
  fixpS :: String
  fixpS = "fixp"
  
  freeofS :: String
  freeofS = "freeof"
  
  numberpS :: String
  numberpS = "numperp"
  
  ordpS :: String
  ordpS = "ordp"
  
  primepS :: String
  primepS = "primep"
  
  convergenceS :: String
  convergenceS = "convergence"
  
  booleanKeywords :: [String]
  booleanKeywords = [ evenpS, fixpS, freeofS, numberpS, ordpS, primepS
                    , convergenceS]
  
  
  -- infix operators
  sym_assignS :: String
  sym_assignS = ":="
  
  sym_equalS :: String
  sym_equalS = "="
  
  
  sym_lessS :: String
  sym_lessS = "<"
  
  sym_greaterS :: String
  sym_greaterS = ">"
  
  sym_geqS :: String
  sym_geqS = ">="
  
  sym_leqS :: String
  sym_leqS = "<="
  
  sym_plusS :: String
  sym_plusS = "+"
  
  sym_minusS :: String
  sym_minusS = "-"
  
  sym_expS :: String
  sym_expS = "^"
  
  sym_divS :: String
  sym_divS = "/"
  
  sym_expmulS :: String
  sym_expmulS = "**"
  
  orS :: String
  orS = "or"
  
  andS :: String
  andS = "and"
  
  memberS :: String
  memberS = "member"
  
  memqS :: String
  memqS = "memq"
  
  equalS :: String
  equalS = "equal"
  
  neqS :: String
  neqS = "neq"
  
  eqS :: String
  eqS = "eq"
  
  geqS :: String
  geqS = "geq"
  
  greaterpS :: String
  greaterpS = "greaterp"
  
  leqS :: String
  leqS = "leq"
  
  lesspS :: String
  lesspS = "lessp"
  
  plusS :: String
  plusS = "plus"
  
  differenceS :: String
  differenceS = "difference"
  
  minusS :: String
  minusS = "minus"
  
  timesS :: String
  timesS = "times"
  
  quotientS :: String
  quotientS = "quotient"
  
  exptS :: String
  exptS = "expt"
  
  consS :: String
  consS = "cons"
  
  
  infixKeywords :: [String]
  infixKeywords = [sym_assignS, sym_equalS, sym_lessS, sym_greaterS, sym_geqS, sym_leqS, sym_plusS, sym_minusS, sym_expS, sym_divS, sym_expmulS, sym_expS, orS, andS, memberS, memqS, equalS, neqS, eqS, geqS, greaterpS, leqS, lesspS, plusS, differenceS, minusS, timesS, quotientS, exptS, consS]
  
  
  -- numerical operators
  absS :: String
  absS = "abs"
  
  acosS :: String
  acosS = "acos"
  
  acoshS :: String
  acoshS = "acosh"
  
  acothS :: String
  acothS = "actoh"
  
  acscS :: String
  acscS = "acsc"
  
  acschS :: String
  acschS = "acsch"
  
  asecS :: String
  asecS = "asec"
  
  asechS :: String
  asechS = "asech"
  
  asinS :: String
  asinS = "asin"
  
  asinhS :: String
  asinhS = "asinh"
  
  atanS :: String
  atanS = "atan"
  
  atanhS :: String
  atanhS = "atanh"
  
  atan2S :: String
  atan2S = "atan2"
  
  cosS :: String
  cosS = "cos"
  
  coshS :: String
  coshS = "cosh"
  
  cotS :: String
  cotS = "cot"
  
  cothS :: String
  cothS = "coth"
  
  cscS :: String
  cscS = "csc"
  
  cschS :: String
  cschS = "csch"
  
  expS :: String
  expS = "exp"
  
  factorialS :: String
  factorialS = "factorial"
  
  fixS :: String
  fixS = "fix"
  
  floorS :: String
  floorS = "floor"
  
  hypotS :: String
  hypotS = "hypot"
  
  lnS :: String
  lnS = "ln"
  
  logS :: String
  logS = "log"
  
  logbS :: String
  logbS = "logb"
  
  log10S :: String
  log10S = "log10"
  
  nextprimeS :: String
  nextprimeS = "nextprime"
  
  roundS :: String
  roundS = "round"
  
  secS :: String
  secS = "sec"
  
  sechS :: String
  sechS = "sech"
  
  sinS :: String
  sinS = "sin"
  
  sinhS :: String
  sinhS = "sinh"
  
  sqrtS :: String
  sqrtS = "sqrt"
  
  tanS :: String
  tanS = "tan"
  
  tanhS :: String
  tanhS = "tanh"
  
  numericalKeywords :: [String]
  numericalKeywords = [absS, acosS, acoshS, acothS, acscS, acschS, asecS, asechS, asinS, asinhS, atanS, atanhS, atan2S, cosS, coshS, cotS, cothS, cscS, cschS, expS, factorialS, fixS, floorS, hypotS, lnS, logS, logbS, log10S, nextprimeS, roundS, secS, sechS, sinS, sinhS, sqrtS, tanS, tanhS]
  
  
  -- prefix operators
  appendS :: String
  appendS = "append"
  
  arglengthS :: String
  arglengthS = " arglenght"
  
  ceilingS :: String
  ceilingS = "ceiling"
  
  coeffS :: String
  coeffS = "coeff"
  
  coeffnS :: String
  coeffnS = "coeffn"
  
  cofactorS :: String
  cofactorS = "cofactor"
  
  conjS :: String
  conjS = "conj"
  
  degS :: String
  degS = "deg"
  
  denS :: String
  denS = "den"
  
  detS :: String
  detS = "det"
  
  defS :: String
  defS = "def"
  
  dilogS :: String
  dilogS = "dilog"
  
  eiS :: String
  eiS = "ei"
  
  epsS :: String
  epsS = "eps"
  
  erfS :: String
  erfS = "erf"
  
  factorizeS :: String
  factorizeS = "factorize"
  
  firstS :: String
  firstS = "first"
  
  gcdS :: String
  gcdS = "gcd"
  
  
  gS :: String
  gS = "g"
  
  impartS :: String
  impartS = "impart"
  
  intS :: String
  intS = "int"
  
  interpolS :: String
  interpolS = "interpol"
  
  lcmS :: String
  lcmS = "lcm"
  
  lcofS :: String
  lcofS = "lcof"
  
  lengthS :: String
  lengthS = "length"
  
  lhsS :: String
  lhsS = "lhs"
  
  linelengthS :: String
  linelengthS = "linelength"
  
  lltermS :: String
  lltermS = "llterm"
  
  mainvarS :: String
  mainvarS = "mainvar"
  
  matS :: String
  matS = "mat"
  
  mateigenS :: String
  mateigenS = "mateigen"
  
  maxS :: String
  maxS = "max"
  
  minS :: String
  minS = "min"
  
  mkidS :: String
  mkidS = "mkid"
  
  nullspaceS :: String
  nullspaceS = "nullspace"
  
  numS :: String
  numS = "num"
  
  partS :: String
  partS = "part"
  
  pfS :: String
  pfS = "pf"
  
  precisionS :: String
  precisionS = "precision"
  
  prodS :: String
  prodS = "prod"
  
  randomS :: String
  randomS = "random"
  
  randomnewseedS :: String
  randomnewseedS = "randomnewseed"
  
  rankS :: String
  rankS = "rank"
  
  rederrS :: String
  rederrS = "rederr"
  
  reductS :: String
  reductS = "reduct"
  
  remainderS :: String
  remainderS = "remainder"
  
  repartS :: String
  repartS = "repart"
  
  restS :: String
  restS = "rest"
  
  resultantS :: String
  resultantS = "resultant"
  
  reverseS :: String
  reverseS = "reverse"
  
  rhsS :: String
  rhsS = "rhs"
  
  secondS :: String
  secondS = "second"
  
  setS :: String
  setS = "set"
  
  showrulesS :: String
  showrulesS = "showrules"
  
  signS :: String
  signS = "sign"
  
  solveS :: String
  solveS = "solve"
  
  structrS :: String
  structrS = "structr"
  
  subS :: String
  subS = "sub"
  
  sumS :: String
  sumS = "sum"
  
  thirdS :: String
  thirdS = "third"
  
  tpS :: String
  tpS = "tp"
  
  traceS :: String
  traceS = "trace"
  
  varnameS :: String
  varnameS = "varname"
  
  prefixKeywords :: [String]
  prefixKeywords = [appendS, arglengthS, ceilingS, coeffS, coeffnS, cofactorS, conjS, degS, denS, detS, defS, dilogS, eiS, epsS, erfS, factorizeS, firstS, gcdS, gS, impartS, intS, interpolS, lcmS, lcofS, lengthS, lhsS, linelengthS, lltermS, mainvarS, matS, mateigenS, maxS, minS, mkidS, nullspaceS, numS, partS, pfS, precisionS, prodS, randomS, randomnewseedS, rankS, rederrS, reductS, remainderS, repartS, restS, resultantS, reverseS, rhsS, secondS, setS, showrulesS, signS, solveS, structrS, subS, sumS, thirdS, tpS, traceS, varnameS]
  
  
  -- reserved variables
  cardnoS :: String
  cardnoS = "cardno"
  
  eS :: String
  eS = "e"
  
  evalmodeS :: String
  evalmodeS = "evalmode"
  
  fortwidthS :: String
  fortwidthS = "fortwidth"
  
  highpowS :: String
  highpowS = "highpow"
  
  iS :: String
  iS = "i"
  
  infinityS :: String
  infinityS = "infinity"
  
  kexlamS :: String
  kexlamS = "k!*"
  
  lowpowS :: String
  lowpowS = "lowpow"
  
  nilS :: String
  nilS = "nil"
  
  piS :: String
  piS = "pi"
  
  rootmultS :: String
  rootmultS = "rootmult"
  
  tS :: String
  tS = "t"
  
  varKeywords :: [String]
  varKeywords = [cardnoS, eS, evalmodeS, fortwidthS, highpowS, iS, infinityS, kexlamS, lowpowS, nilS, piS, rootmultS, tS]
  
  
  -- switches
  
  adjprecS :: String
  adjprecS = "adjprec"
  
  algintS :: String
  algintS = "algint"
  
  allbranchS :: String
  allbranchS = "allbranch"
  
  allfacS :: String
  allfacS = "allfac"
  
  balancemodS :: String
  balancemodS = "balancemod"
  
  bfspaceS :: String
  bfspaceS = "bfspace"
  
  combineexptS :: String
  combineexptS = "comineexpt"
  
  defnS :: String
  defnS = "defn"
  
  demoS :: String
  demoS = "demo"
  
  divS :: String
  divS = "div"
  
  echoS :: String
  echoS = "echo"
  
  errcontS :: String
  errcontS = "errcont"
  
  evallhseqpS :: String
  evallhseqpS = "evallhseqp"
  
  
  expandlogsS :: String
  expandlogsS = "expandlogs"
  
  ezgcdS :: String
  ezgcdS = "ezgcd"
  
  fortS :: String
  fortS = "fort"
  
  fullrootsS :: String
  fullrootsS = "fullroots"
  
  ifactorS :: String
  ifactorS = "ifactor"
  
  
  intstrS :: String
  intstrS = "intstr"
  
  
  listS :: String
  listS = "list"
  
  listargsS :: String
  listargsS = "listargs"
  
  mcdS :: String
  mcdS = "mcd"
  
  modularS :: String
  modularS = "modular"
  
  msgS :: String
  msgS = "msg"
  
  multiplicitiesS :: String
  multiplicitiesS = "multiplicities"
  
  natS :: String
  natS = "nat"
  
  neroS :: String
  neroS = "nero"
  
  nosplitS :: String
  nosplitS = "nosplit"
  
  outputS :: String
  outputS = "output"
  
  periodS :: String
  periodS = "period"
  
  preciseS :: String
  preciseS = "precise"
  
  pretS :: String
  pretS = "pret"
  
  priS :: String
  priS = "pri"
  
  ratS :: String
  ratS = "rat"
  
  ratargS :: String
  ratargS = "ratargs"
  
  rationalS :: String
  rationalS = "rational"
  
  rationalizeS :: String
  rationalizeS = "rationalize"
  
  ratrpiS :: String
  ratrpiS = "ratrpi"
  
  revpriS :: String
  revpriS = "repvpri"
  
  rlisp88S :: String
  rlisp88S = "rlisp88"
  
  roundallS :: String
  roundallS = "roundall"
  
  roundbdS :: String
  roundbdS = "roundbd"
  
  roundedS :: String
  roundedS = "rounded"
  
  savestructrS :: String
  savestructrS = "savestructr"
  
  solvesingularS :: String
  solvesingularS = "solvesingular"
  
  timeS :: String
  timeS = "times"
  
  traS :: String
  traS = "tra"
  
  trfacS :: String
  trfacS = "trafac"
  
  trigformS :: String
  trigformS = "trigform"
  
  
  trintS :: String
  trintS = "trint"
  
  switchKeywords :: [String]
  switchKeywords = [adjprecS, algintS, allbranchS, allfacS, balancemodS, bfspaceS, combineexptS, defnS, demoS, divS, echoS, errcontS, evallhseqpS, expS, expandlogsS, ezgcdS, factorS, fortS, fullrootsS, gcdS, ifactorS, intS, intstrS, lcmS, listS, listargsS, mcdS, modularS, msgS, multiplicitiesS, natS, neroS, nosplitS, outputS, periodS, preciseS, pretS, priS, ratS, ratargS, rationalS, rationalizeS, ratrpiS, revpriS, rlisp88S, roundallS, roundbdS, roundedS, savestructrS, solvesingularS, timeS, traS, trfacS, trigformS, trintS]
  
  
  -- others
  beginS :: String
  beginS = "begin"
  
  doS :: String
  doS = "do"
  
  exprS :: String
  exprS = "expr"
  
  fexprS :: String
  fexprS = "fexpr"
  
  lambdaS :: String
  lambdaS = "lambda"
  
  macroS :: String
  macroS = "macro"
  
  productS :: String
  productS = "product"
  
  repeatS :: String
  repeatS = "repeat"
  
  smacroS :: String
  smacroS = "scmacro"
  
  untilS :: String
  untilS = "until"
  
  whenS :: String
  whenS = "when"
  
  whileS :: String
  whileS = "while"
  
  wsS :: String
  wsS = "ws"
  
  otherKeywords :: [String]
  otherKeywords = [beginS, doS, exprS, fexprS, inputS, lambdaS, lispS, macroS, productS, repeatS, smacroS, sumS, untilS, whenS, whileS, wsS]
  
  
  --
  allKeywords :: [String]
  allKeywords = commandKeywords ++ booleanKeywords ++ infixKeywords ++ numericalKeywords ++ prefixKeywords ++ varKeywords ++ switchKeywords ++ otherKeywords
  