Calc

local tArgs = {...}
local debugOn = false
local mode = tArgs[1]=="buttons" and 1 or 2
--debugFile = "/calc-debug"
--file=fs.open(debugFile, "w") file.close()
local termX, termY = term.getSize()
local function display(...) if mode==2 then term.clearLine() print(...) if ({term.getCursorPos()})[2] == termY then term.scroll(1) term.setCursorPos(1, termY-1) term.write(string.rep("-", termX)) term.setCursorPos(1, termY-1) end elseif mode==1 then local args={...} for i=1,#args do args[i] = tostring(args[i]) end term.setCursorPos(1,1) term.clearLine() local text = table.concat(args) text = text:sub(#text-termX) term.write(text) end if debugOn then local args = {...} local textArgs = {} for i=1,#args do textArgs[i] = tostring(args[i]) end local text = table.concat(textArgs) local file = fs.open(debugFile, "a") file.writeLine(text) file.close() end end
local function debug(...) if debugOn then display(...) end return ... end

local defaultFile = [=[
--[[
This is the custom settings file. Custom operators
functions, and constants can be added like this:

Operator{
  symbol = "+",
  precedence = 32,
  func = function(a,b) return a+b end,
  associativity = "left"
}

The fields precedence and associativity are
optional. Precedence is a positive number, and
operators with higher precedences are evaluated
first. Default for precedence is 1. Associativity
may be "left" or "right, and determines the
operands to evaluate when two operators have equal
precedence. Default for associativity is "left".
In addition, there is another optional field,
variables. If it is set to true, variables will
be passed to operator function as the the name,
as a string, instead of the value. Unless you're
doing something special, you shouldn't use this.
If you do need to interact with variables, they
are stored in the table vars, and may be accessed
by vars[name].

You may also add custom constants, like this:

Constant{
  name = "thirteen",
  value = 13
}

Lastly, you can add custom functions:

Function{
  name = "rand",
  arguments = 1,
  func = math.rand
}

Functions must have a specified number of
arguments, and any other arguments passed to them
will be ignored. The variables field also applies
to functions.
]]

--Content goes below here:
]=]

local function tokenize(expression) -- Done
 debug("Tokenizing expression: " .. expression)
 expression = string.gsub(expression, "%s+", "")
 debug("Removed Whitespace\nNew expression: ".. expression)
 local tokens = {}
 local matched = false
 for token1, number, token2 in string.gmatch(expression, "([^%d]*)(%d*%.?%d+)([^%d]*)") do
  matched = true
  debug("Found match\nSeperating first set of tokens")
  while token1 ~= "" do
   local match, pos = string.match(token1, "^(%a+)()")
   if match then
    table.insert(tokens, match)
    token1 = token1:sub(pos)
   else
    table.insert(tokens ,token1:sub(1,1))
    token1 = token1:sub(2)
   end
  end
  table.insert(tokens, number)
  debug("Seperating second set of tokens")
  while token2 ~= "" do
   local match, pos = string.match(token2, "^(%a+)()")
   if match then
    table.insert(tokens, match)
    token2 = token2:sub(pos)
   else
    table.insert(tokens ,token2:sub(1,1))
    token2 = token2:sub(2)
   end
  end
 end
 if not matched then
  while expression ~= "" do
   local match, pos = string.match(expression, "^(%a+)()")
   if match then
    table.insert(tokens, match)
    expression = expression:sub(pos)
   else
    table.insert(tokens ,expression:sub(1,1))
    expression = expression:sub(2)
   end
  end
 end
 debug("Returning from tokenize")
 if tokens == {} then display("Unable to parse expression") return else return tokens end
end

local functions = {
sin = {func = math.sin, args = 1},
cos = {func = math.cos, args = 1},
tan = {func = math.tan, args = 1},
random = {func = math.random, args = 0},
abs = {func = math.abs, args = 1},
acos = {func = math.acos, args = 1},
asin = {func = math.asin, args = 1},
atan = {func = math.atan, args = 1},
atan2 = {func = math.atan2, args = 2},
ceil = {func = math.ceil, args = 1},
cosh = {func = math.cosh, args = 1},
deg = {func = math.deg, args = 1},
exp = {func = math.exp, args = 1},
floor = {func = math.floor, args = 1},
fmod = {func = math.fmod, args = 2},
frexp = {func = math.frexp, args = 1},
ldexp = {func = math.ldexp, args = 2},
log = {func = math.log, args = 1},
logten = {func = function(num) return math.log(num, 10) end, args = 1},
logtwo = {func = function(num) return math.log(num, 2) end, args = 1},
logbase = {func = math.log, args = 2},
min = {func = math.min, args = 2},
max = {func = math.max, args = 2},
pow = {func = math.pow, args = 2},
rad = {func = math.rad, args = 1},
randomseed = {func = math.randomseed, args = 1},
sinh = {func = math.sinh, args = 1},
sqrt = {func = math.sqrt, args = 1},
tanh = {func = math.tanh, args = 1},
randomrange = {func = math.random, args = 2}
}

local constants = {
pi = math.pi,
e = math.exp(1),
inf = math.huge
}

local operators = {
["+"] = {func = function(a,b) return a+b end, precedence = 32, leftAssociative = true, args = 2},
["-"] = {func = function(a,b) return a-b end, precedence = 32, leftAssociative = true, args = 2},
["*"] = {func = function(a,b) return a*b end, precedence = 64, leftAssociative = true, args = 2},
["/"] = {func = function(a,b) return a/b end, precedence = 64, leftAssociative = true, args = 2},
["^"] = {func = function(a,b) return a^b end, precedence = 96, leftAssociative = false, args = 2},
["%"] = {func = function(a,b) return a%b end, precedence = 64, leftAssociative = true, args = 2},
["="] = {func = function(a,b) debug("= recieved args: ",a," and ",b) if not tonumber(a) then vars[a] = vars[b] debug("Set variable ",a," to ",vars[b]) else debug("Did not set variable: ",a," to ",vars[b]) end return b end, precedence = 16, leftAssociative = false, args = 2, getVars = true}
}

setmetatable(functions, {__index = operators})

vars = {}
setmetatable(vars, {__index = function(_, value) return tonumber(value) end})

local function shuntingYard(tokens) -- Done
 debug("Shunting yard input: ", table.concat(tokens, " "))
 local output = {}
 local stack = {}
 local x = #tokens
 while #tokens>0 do
  if x>0 then debug("Tokens left: ",#tokens) x=x-1 end
  debug("Stack: ",table.concat(stack, " "))
  local token = table.remove(tokens, 1)
  if tonumber(token) and token~="-" then debug("Token is a number: ",token)
   table.insert(output, tonumber(token))
  elseif operators[token] then debug("Token is an operator: ",token)
   while operators[stack[#stack]] and ((operators[token].leftAssociative and operators[token].precedence <= operators[stack[#stack]].precedence) or operators[token].precedence < operators[stack[#stack]].precedence) do
    table.insert(output, table.remove(stack))
   end
   table.insert(stack, token)
  elseif functions[token] then debug("Token is a function: ",token)
   table.insert(stack, token)
  elseif token == "," then debug("Token is a comma")
   local leftParen = false
   while #stack > 0 do
    if stack[#stack] == "(" then
     leftParen = true
     break
    end
    table.insert(output, table.remove(stack))
   end
   if not leftParen then
    display("Error: misplaced comma or parentheses")
    return false
   end
  elseif token == "(" then debug("Token is a left parentheses")
   table.insert(stack, token)
  elseif token == ")" then debug("Token is a right parentheses")
   local leftParen = false
   while #stack > 0 do
    if stack[#stack] == "(" then
     table.remove(stack)
     leftParen = true
     if functions[stack[#stack]] then
      table.insert(output, table.remove(stack))
     end
     break
    else
     table.insert(output, table.remove(stack))
    end
   end
   if not leftParen then
    display("Error: mismatched parentheses")
    return false
   end
  elseif constants[token] then debug("Token is a constant: ",constants[token])
   table.insert(output, constants[token])
  elseif vars[token] ~= token then debug("Token is a variable: ",token)
   table.insert(output, "var:"..token)
  elseif token == string.match(token, "%a+") then debug("Token is a possible variable: ",token)
   table.insert(output, "var:"..token)
  else
   display("Error: unknown symbol or identifier")
   return false
  end
 end
 x=#stack
 debug("Items in stack = ",x)
 while #stack > 0 do
  if x>0 then debug("Token in stack: ",stack[#stack]) x=x-1 end
  if stack[#stack] == "(" or stack[#stack] == ")" then
   display("Error: mismatched parentheses")
   return false
  end
  table.insert(output, table.remove(stack))
 end
 debug("Shunting yard output: ", table.concat(output, " "))
 return output
end

local function operator(op)
 if type(op) ~= "table" then return end
 if type(op.symbol) == "string" and #op.symbol==1 and not string.match(op.symbol, "%w") and type(op.func == "function") then
  if type(op.precedence)~="number" or op.precedence<=0 then op.precedence = 1 end
  if op.associativity ~= "left" and op.associativity ~= "right" then op.associativity = "left" end
  operators[op.symbol] = {func = op.func, precedence = op.precedence, leftAssociative = op.associativity == "left", args = 2}
  if op.variables then operators[op.symbol].getVars = true end
  debug("Added operator: ",op.symbol)
 end
end

local function constant(con)
 if type(con) ~= "table" then return end
 if type(con.name) == "string" and type(con.value) == "number" then
  constants[name] = value
 end
end

local function func(fun)
 if type(fun) ~= "table" then return end
 if type(fun.name) == "string" and string.match(fun.name, "%a+") == fun.name and type(fun.arguments) == "number" and fun.arguments >= 0 and type(fun.func) == "function" then
  functions[fun.name] = {func = fun.func, args = fun.arguments}
  if fun.variables then functions[fun.name].getVars = true end
 end
end

local function loadCustom() -- Done
 display("Loading custom settings")
 if not fs.exists("Programs/calculator/custom") then
  if not pcall(fs.makeDir, "Programs/calculator") then
   display("Unable to create directory /Programs/calculator")
   return false
  end
  local file = fs.open("Programs/calculator/custom", "w")
  file.write(defaultFile)
  file.close()
  display("Custom settings file created at /Programs/calculator/custom")
 end
 customFile = loadfile("Programs/calculator/custom")
 if not customFile then display("Error: failed to load custom settings")
  return false
 end
 setfenv(customFile, {Operator = operator, Constant = constant, Function = func})
 ok = pcall(customFile)
 if not ok then display("Error: failed to load custom settings")
  return false
 else display("Successfully loaded custom settings")
 end
end

local function evaluate(expression) -- Done
 local stack = {}
 local x=#expression
 while #expression > 0 do
  if x>0 then debug("Evaluating for token: ",expression[#expression]) x=x-1 end
  table.insert(stack, table.remove(expression, 1))
  if functions[stack[#stack]] then
   debug("Applying function: ",stack[#stack]," to stack: ",table.concat(stack," "))
   local func = functions[table.remove(stack)]
   if #stack<func.args then display("Error: Invalid expression") return false end
   local operands = {}
   local newSize = #stack-func.args
   while #stack > newSize do
    table.insert(operands, table.remove(stack, newSize+1))
   end
   for index,operand in ipairs(operands) do
    if string.sub(operand, 1, 4) == "var:" then
     if not operand:sub(5):match("%a+") then display("Error: Invalid expression") return false end
     if func.getVars then operands[index] = string.sub(operand, 5) else operands[index] = vars[string.sub(operand, 5)] end
    end
    if not operands[index] then display("Variable ", string.sub(operand, 5), " does not exist") return false end
   end
   if #operands ~= func.args then display("An unknown error occured while evaluating") return false end
   table.insert(stack, func.func(unpack(operands)))
  elseif type(stack[#stack])~="number" and string.sub(stack[#stack], 1, 4) ~= "var:" then
   display("An unknown token was encountered while evaluating")
   return false
  end
 end
 if #stack ~= 1 then
  display("Error: Invalid expression")
  return false
 end
 local result = stack[1] debug("Result is ",result)
 if string.sub(result, 1, 4)=="var:" then if not result:sub(5):match("%a+") then display("Error: Invalid expression") return false end debug("Result is variable: ",result) result = vars[string.sub(result,5)] debug("New result = ",result) end
 if not result then result = "That variable is not defined" end
 return result
end

local function fixArgs(expression)
 return expression
end

local function fixNegative(expression)
 local currentPos = 1
 while true do
  local startPos, endPos = string.find(expression, "%-%d+", currentPos)
  if not startPos then break end
  currentPos = endPos+1
  if not string.match(string.sub(expression, startPos-1, startPos-1), "[%a%d%)]") then
   expression = string.sub(expression, 1, startPos-1).."0"..string.sub(expression, startPos)
  end
 end
 debug("fixNegative produced " .. expression)
 return expression
end

local function command(expression)
 local cmd, param = string.match(expression, "(%a+)%s?(%a*)")
 local commands = {
  delete = function(var) if var == "" or var == " " then display("No variable specifed to delete") return "delete" end if vars[var] then vars[var] = nil display("Deleted variable: ",var) else display(var," is not a variable") end return "delete" end,
  vars = function() local found = false for var,value in pairs(vars) do found = true display(var,"=",value) end if not found then display("There are no variables") end return "vars" end,
  ["exit"] = function(e) if e == "" then return "exit" end end,
  get = function(param) if functions[param] then display("Function") elseif constants[param] then display("Constant: ", constants[param]) elseif vars[param] then display("Variable: ", vars[param]) else display("Not a function, constant, or variable") end return "get" end,
  buttons = function() mode = 1 return "exit" end,
  --debug = function(on) if on=="on" then debugOn=true display("Debug Enabled") elseif on=="off" then debugOn=false display("Debug Disabled") end return "debug" end,
  --log = function(load) if load == "reload" then reload = true end shell.run("edit", debugFile) return "exit" end,
  --reload = function() reload = true return "exit" end,
 }
 commands.commands = function() local cmds = {} for key in pairs(commands) do table.insert(cmds, key) end local list = "Commands: "..table.concat(cmds, ", ") display(list) return "commands" end
 if commands[cmd] then return commands[cmd](param) end
end

local function textUI()
 local history = {}
 term.clear()
 if ({term.getCursorPos()})[2] == termY then term.scroll(1) end
 term.setCursorPos(1, termY-1)
 term.write(string.rep("-", termX))
 term.setCursorPos(1, termY-1)
 term.setCursorPos(1, termY)
 loadCustom()
 local running = true
 term.setCursorBlink(true)
 while running do
 while running do
  if ({term.getCursorPos()})[2] == termY then term.scroll(1) end
  term.setCursorPos(1, termY-1)
  term.write(string.rep("-", termX))
  term.setCursorPos(1, termY-1)
  term.setCursorPos(1, termY)
  write("Input: ")
  local expression = read(nil, history)
  term.setCursorPos(1, termY-1)
  term.scroll(1)
  term.clearLine()
  table.insert(history, expression)
  local cmd = command(expression)
  if cmd then if cmd == "exit" then running = false end break end
  expression = fixNegative(expression)
  if not expression then break end
  expression = fixArgs(expression)
  if not expression then break end
  expression = tokenize(expression)
  if not expression then break end
  expression = shuntingYard(expression)
  if not expression then break end
  expression = evaluate(expression)
  if not expression then break end
  display("Result: ", expression)
 end
 end
 term.setCursorPos(1, termY)
end

local function GUI()
 if termY < 18 or termX < 23 then print("Error: Terminal is too small") return end
 local running = true
 term.setCursorBlink(false)
 term.clear()
 local row, column = 1, 1
 local rowMax, columnMax = 5, 4
 local symbols = {
  {"<--", " ( ", " ) ", "adv"},
  {" 7 ", " 8 ", " 9 ", " / "},
  {" 4 ", " 5 ", " 6 ", " * "},
  {" 1 ", " 2 ", " 3 ", " - "},
  {" 0 ", " . ", " = ", " + "}
 }
 local function buttonFunctions(rowNum, columnNum)
  if rowNum == 1 and columnNum == 1 then return function(e) return string.sub(e, 1, #e-1) end
  elseif rowNum == 1 and columnNum == 4 then return function() running = false mode = 2 return "" end
  elseif rowNum == 5 and columnNum == 3 then return function(expression)
   term.setCursorPos(1,1) term.clearLine()
   for _=1,1 do
    expression = fixNegative(expression)
    if not expression then break end
    expression = fixArgs(expression)
    if not expression then break end
    expression = tokenize(expression)
    if not expression then break end
    expression = shuntingYard(expression)
    if not expression then break end
    expression = evaluate(expression)
    if not expression then break end
    display("Result: ",expression)
   end
   sleep(2)--while true do local e,p=os.pullEvent("key") if p~=1 then break end end
   return ""
  end
  else return function(e) return e..symbols[rowNum][columnNum]:sub(2,2) end end
 end
 local yPos = {4, 7, 10, 13, 16}
 local xPos = {1, 7, 13, 19}
 for i=1,4 do xPos[i] = xPos[i] + math.floor((termX-23)/2) end
 local function button(y, x, symbol, highlight)
  local border = highlight and "=====" or "-----"
  term.setCursorPos(x, y)
  term.write(border)
  term.setCursorPos(x, y+1)
  term.write("|"..symbol.."|")
  term.setCursorPos(x, y+2)
  term.write(border)
 end
 for row=1,rowMax do
 for column=1,columnMax do
  button(yPos[row], xPos[column], symbols[row][column], (row == 1 and column == 1) and true)
 end
 end
 local expression = ""
 term.setCursorPos(1, 2) term.clearLine() term.write(string.rep("-", termX))
 while running do
 while running do
  local e,p = os.pullEvent("key")
  if p == 28 then
   expression = buttonFunctions(row, column)(expression)
   display(expression)
  elseif p == 200 and row > 1 then
   button(yPos[row], xPos[column], symbols[row][column], false)
   row = row - 1
   button(yPos[row], xPos[column], symbols[row][column], true)
  elseif p == 208 and row < rowMax then
   button(yPos[row], xPos[column], symbols[row][column], false)
   row = row + 1
   button(yPos[row], xPos[column], symbols[row][column], true)
  elseif p == 203 and column > 1 then
   button(yPos[row], xPos[column], symbols[row][column], false)
   column = column - 1
   button(yPos[row], xPos[column], symbols[row][column], true)
  elseif p == 205 and column < columnMax then
   button(yPos[row], xPos[column], symbols[row][column], false)
   column = column + 1
   button(yPos[row], xPos[column], symbols[row][column], true)
  end
 end
 end
 term.clear()
 term.setCursorPos(1,1)
end

local function main()
 local currentMode
 local modes = {GUI, textUI}
 repeat
  currentMode = mode
  modes[mode]()
 until currentMode == mode
end

main()