1017 lines
37 KiB
Swift
1017 lines
37 KiB
Swift
//
|
|
// MTMathListBuilder.swift
|
|
// MathRenderSwift
|
|
//
|
|
// Created by Mike Griebling on 2022-12-31.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
/** `MTMathListBuilder` is a class for parsing LaTeX into an `MTMathList` that
|
|
can be rendered and processed mathematically.
|
|
*/
|
|
class MTEnvProperties {
|
|
var envName: String?
|
|
var ended: Bool
|
|
var numRows: Int
|
|
|
|
init(name: String?) {
|
|
self.envName = name
|
|
self.numRows = 0
|
|
self.ended = false
|
|
}
|
|
}
|
|
|
|
/**
|
|
@typedef case s
|
|
@brief The error encountered when parsing a LaTeX string.
|
|
|
|
The `code` in the `NSError` is one of the following indiciating why the LaTeX string
|
|
could not be parsed.
|
|
*/
|
|
enum MTParseErrors:Int {
|
|
/// The braces { } do not match.
|
|
case mismatchBraces = 1
|
|
/// A command in the string is not recognized.
|
|
case invalidCommand
|
|
/// An expected character such as ] was not found.
|
|
case characterNotFound
|
|
/// The \left or \right command was not followed by a delimiter.
|
|
case missingDelimiter
|
|
/// The delimiter following \left or \right was not a valid delimiter.
|
|
case invalidDelimiter
|
|
/// There is no \right corresponding to the \left command.
|
|
case missingRight
|
|
/// There is no \left corresponding to the \right command.
|
|
case missingLeft
|
|
/// The environment given to the \begin command is not recognized
|
|
case invalidEnv
|
|
/// A command is used which is only valid inside a \begin,\end environment
|
|
case missingEnv
|
|
/// There is no \begin corresponding to the \end command.
|
|
case missingBegin
|
|
/// There is no \end corresponding to the \begin command.
|
|
case missingEnd
|
|
/// The number of columns do not match the environment
|
|
case invalidNumColumns
|
|
/// Internal error, due to a programming mistake.
|
|
case internalError
|
|
/// Limit control applied incorrectly
|
|
case invalidLimits
|
|
}
|
|
|
|
let MTParseError = "ParseError"
|
|
|
|
public class MTMathListBuilder {
|
|
var string: String
|
|
var currentCharIndex: String.Index
|
|
var currentInnerAtom: MTInner?
|
|
var currentEnv: MTEnvProperties?
|
|
var currentFontStyle:MTFontStyle
|
|
var spacesAllowed:Bool
|
|
|
|
/** Contains any error that occurred during parsing. */
|
|
var error:NSError?
|
|
|
|
var hasCharacters: Bool { currentCharIndex < string.endIndex }
|
|
|
|
public static let spaceToCommands: [CGFloat: String] = [
|
|
3 : ",",
|
|
4 : ">",
|
|
5 : ";",
|
|
(-3) : "!",
|
|
18 : "quad",
|
|
36 : "qquad",
|
|
]
|
|
|
|
public static let styleToCommands: [MTLineStyle: String] = [
|
|
.display: "displaystyle",
|
|
.text: "textstyle",
|
|
.script: "scriptstyle",
|
|
.scriptOfScript: "scriptscriptstyle"
|
|
]
|
|
|
|
init(string: String) {
|
|
self.string = string
|
|
self.currentCharIndex = string.startIndex
|
|
self.currentFontStyle = .defaultStyle
|
|
self.spacesAllowed = false
|
|
}
|
|
|
|
func build() -> MTMathList? {
|
|
if let list = self.buildInternal(false) {
|
|
if self.hasCharacters {
|
|
print("Mismatched braces: \(self.string)")
|
|
return nil
|
|
}
|
|
return list
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
public static func build(fromString string: String) -> MTMathList? {
|
|
let builder = MTMathListBuilder(string: string)
|
|
return builder.build()
|
|
}
|
|
|
|
public static func build(fromString string: String, error:inout NSError?) -> MTMathList? {
|
|
let builder = MTMathListBuilder(string: string)
|
|
let output = builder.build()
|
|
if builder.error != nil {
|
|
if error != nil {
|
|
error = builder.error
|
|
}
|
|
return nil
|
|
}
|
|
return output
|
|
}
|
|
|
|
public static func mathListToString(_ ml: MTMathList?) -> String {
|
|
var output = ""
|
|
|
|
if let atomList = ml {
|
|
for atom in atomList.atoms {
|
|
switch atom.type {
|
|
case .fraction:
|
|
if let frac = atom as? MTFraction {
|
|
if frac.hasRule {
|
|
output += "\\frac{\(mathListToString(frac.numerator!))}{\(mathListToString(frac.denominator!))}"
|
|
} else {
|
|
var command: String? = nil
|
|
|
|
if frac.leftDelimiter == nil && frac.rightDelimiter == nil {
|
|
command = "atop"
|
|
} else if frac.leftDelimiter == "(" && frac.rightDelimiter == ")" {
|
|
command = "choose"
|
|
} else if frac.leftDelimiter == "{" && frac.rightDelimiter == "}" {
|
|
command = "brace"
|
|
} else if frac.leftDelimiter == "[" && frac.rightDelimiter == "]" {
|
|
command = "brack"
|
|
} else {
|
|
command = "atopwithdelims\(frac.leftDelimiter!)\(frac.rightDelimiter!)"
|
|
}
|
|
|
|
output += "{\(mathListToString(frac.numerator!)) \\\(command!) \(mathListToString(frac.denominator!))}"
|
|
}
|
|
}
|
|
break
|
|
case .radical:
|
|
output += "\\sqrt"
|
|
if let rad = atom as? MTRadical {
|
|
if rad.degree != nil {
|
|
output += "[\(mathListToString(rad.degree!))]"
|
|
}
|
|
output += "{\(mathListToString(rad.radicand!))}"
|
|
}
|
|
break
|
|
case .inner:
|
|
if let inner = atom as? MTInner {
|
|
if inner.leftBoundary != nil || inner.rightBoundary != nil {
|
|
if inner.leftBoundary != nil {
|
|
output += "\\left\(delimToString(delim: inner.leftBoundary!))"
|
|
} else {
|
|
output += "\\left. "
|
|
}
|
|
|
|
output += mathListToString(inner.innerList!)
|
|
|
|
if inner.rightBoundary != nil {
|
|
output += "\\right\(delimToString(delim: inner.rightBoundary!))"
|
|
} else {
|
|
output += "\\right. "
|
|
}
|
|
} else {
|
|
output += "{\(mathListToString(inner.innerList!))}"
|
|
}
|
|
}
|
|
break
|
|
case .table:
|
|
if let table = atom as? MTMathTable {
|
|
if table.environment != nil {
|
|
output += "\\begin{\(table.environment!)}"
|
|
}
|
|
|
|
for i in 0..<table.numberOfRows() {
|
|
for j in 0..<table.cells[i].count {
|
|
let cell = table.cells[i][j]
|
|
|
|
if table.environment == "matrix" {
|
|
if cell.atoms.count >= 1 && cell.atoms[0].type == .style {
|
|
// remove first atom
|
|
cell.atoms.removeFirst()
|
|
}
|
|
}
|
|
if table.environment == "eqalign" || table.environment == "aligned" || table.environment == "split" {
|
|
if j == 1 && cell.atoms.count >= 1 && cell.atoms[0].type == .ordinary && cell.atoms[0].nucleus.count == 0 {
|
|
// remove empty nucleus added for spacing
|
|
cell.atoms.removeFirst()
|
|
}
|
|
}
|
|
|
|
output += mathListToString(cell)
|
|
|
|
if j < table.cells[i].count {
|
|
output += "&"
|
|
}
|
|
}
|
|
if i < table.numberOfRows() - 1 {
|
|
output += "\\\\ "
|
|
}
|
|
}
|
|
|
|
if table.environment != nil {
|
|
output += "\\end{\(table.environment!)}"
|
|
}
|
|
}
|
|
break
|
|
case .overline:
|
|
if let overline = atom as? MTOverLine {
|
|
output += "\\overline"
|
|
output += "{\(mathListToString(overline.innerList!))}"
|
|
}
|
|
break
|
|
case .underline:
|
|
if let underline = atom as? MTUnderLine {
|
|
output += "\\underline"
|
|
output += "{\(mathListToString(underline.innerList!))}"
|
|
}
|
|
break
|
|
case .accent:
|
|
if let accent = atom as? MTAccent {
|
|
output += "\\\(MTMathAtomFactory.getName(of: accent)!){\(mathListToString(accent.innerList!))}"
|
|
}
|
|
break
|
|
case .space:
|
|
if let space = atom as? MTMathSpace {
|
|
if let command = MTMathListBuilder.spaceToCommands[space.space] {
|
|
output += "\\\(command)"
|
|
} else {
|
|
output += String.init(format: "\\mkern%.1fmu", space.space)
|
|
}
|
|
}
|
|
break
|
|
case .style:
|
|
if let style = atom as? MTMathStyle {
|
|
if let command = MTMathListBuilder.styleToCommands[style.style] {
|
|
output += "\\\(command)"
|
|
}
|
|
}
|
|
break
|
|
default:
|
|
if atom.nucleus.count == 0 {
|
|
output += "{}"
|
|
} else if atom.nucleus == "\u{2236}" {
|
|
output += ":"
|
|
} else if atom.nucleus == "\u{2212}" {
|
|
output += "-"
|
|
} else {
|
|
if let command = MTMathAtomFactory.latexSymbolName(for: atom) {
|
|
output += "\\\(command)"
|
|
} else {
|
|
output += "\(atom.nucleus)"
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
if atom.superScript != nil {
|
|
output += "^{\(mathListToString(atom.superScript!))}"
|
|
}
|
|
|
|
if atom.subScript != nil {
|
|
output += "_{\(mathListToString(atom.subScript!))}"
|
|
}
|
|
}
|
|
}
|
|
return output
|
|
}
|
|
|
|
public static func delimToString(delim: MTMathAtom) -> String {
|
|
if let command = MTMathAtomFactory.getDelimiterName(of: delim) {
|
|
let singleChars = [ "(", ")", "[", "]", "<", ">", "|", ".", "/"]
|
|
if singleChars.contains(command) {
|
|
return command
|
|
} else if command == "||" {
|
|
return "\\|"
|
|
} else {
|
|
return "\\\(command)"
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
func getNextCharacter() -> Character? {
|
|
assert(self.hasCharacters, "Retrieving character at index \(self.currentCharIndex) beyond length \(self.string.count)")
|
|
if self.hasCharacters {
|
|
let ch = string[currentCharIndex]
|
|
currentCharIndex = string.index(after: currentCharIndex)
|
|
return ch
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func unlookCharacter() {
|
|
assert(currentCharIndex > string.startIndex, "Unlooking when at the first character.")
|
|
if currentCharIndex > string.startIndex {
|
|
currentCharIndex = string.index(before: currentCharIndex)
|
|
} else {
|
|
print("unlooking at first character")
|
|
}
|
|
}
|
|
|
|
func buildInternal(_ oneCharOnly: Bool) -> MTMathList? {
|
|
return self.buildInternal(oneCharOnly, stop: nil)
|
|
}
|
|
|
|
func buildInternal(_ oneCharOnly: Bool, stop: Character?) -> MTMathList? {
|
|
let list = MTMathList()
|
|
assert(!(oneCharOnly && stop != nil), "Cannot set both oneCharOnly and stopChar.")
|
|
var prevAtom: MTMathAtom? = nil
|
|
while self.hasCharacters {
|
|
if error != nil { return nil }
|
|
|
|
var atom: MTMathAtom? = nil
|
|
let char = self.getNextCharacter()!
|
|
|
|
if oneCharOnly {
|
|
if char == "^" || char == "}" || char == "_" || char == "&" {
|
|
self.unlookCharacter()
|
|
return list
|
|
}
|
|
}
|
|
|
|
if stop != nil && char == stop {
|
|
return list
|
|
}
|
|
|
|
if char == "^" {
|
|
assert(!oneCharOnly, "This should have been handled before")
|
|
if (prevAtom == nil || prevAtom!.superScript != nil || !prevAtom!.isScriptAllowed()) {
|
|
// If there is no previous atom, or if it already has a superscript
|
|
// or if scripts are not allowed for it, then add an empty node.
|
|
prevAtom = MTMathAtom(type: .ordinary, value: "")
|
|
list.add(prevAtom!)
|
|
}
|
|
|
|
prevAtom!.setSuperScript(self.buildInternal(true))
|
|
continue
|
|
} else if char == "_" {
|
|
assert(!oneCharOnly, "This should have been handled before")
|
|
if (prevAtom == nil || prevAtom!.subScript != nil || !prevAtom!.isScriptAllowed()) {
|
|
// If there is no previous atom, or if it already has a subcript
|
|
// or if scripts are not allowed for it, then add an empty node.
|
|
prevAtom = MTMathAtom(type: .ordinary, value: "")
|
|
list.add(prevAtom!)
|
|
}
|
|
prevAtom!.setSubScript(self.buildInternal(true))
|
|
continue
|
|
} else if char == "{" {
|
|
// this puts us in a recursive routine, and sets oneCharOnly to false and no stop character
|
|
if let subList = self.buildInternal(false, stop: "}") {
|
|
prevAtom = subList.atoms.last
|
|
list.append(subList)
|
|
if oneCharOnly {
|
|
return list
|
|
}
|
|
continue
|
|
} else {
|
|
print("open brackets but inner...")
|
|
return nil
|
|
}
|
|
} else if char == "}" {
|
|
assert(!oneCharOnly, "This should have been handled before")
|
|
assert(stop == nil, "This should have been handled before")
|
|
// We encountered a closing brace when there is no stop set, that means there was no
|
|
// corresponding opening brace.
|
|
print("Mismatched braces")
|
|
return nil
|
|
} else if char == "\\" {
|
|
let command = readCommand()
|
|
let done = stopCommand(command, list:list, stop:stop)
|
|
if done != nil {
|
|
return done
|
|
} else if error != nil {
|
|
return nil
|
|
}
|
|
if self.applyModifier(command, atom:prevAtom) {
|
|
continue;
|
|
}
|
|
let fontStyle = MTMathAtomFactory.fontStyleWithName(command)
|
|
if fontStyle != nil {
|
|
let oldSpacesAllowed = spacesAllowed
|
|
// Text has special consideration where it allows spaces without escaping.
|
|
spacesAllowed = command == "text"
|
|
let oldFontStyle = currentFontStyle
|
|
currentFontStyle = fontStyle!
|
|
let sublist = self.buildInternal(true)!
|
|
// Restore the font style.
|
|
currentFontStyle = oldFontStyle
|
|
spacesAllowed = oldSpacesAllowed
|
|
|
|
prevAtom = sublist.atoms.last
|
|
list.append(sublist)
|
|
if oneCharOnly {
|
|
return list
|
|
}
|
|
continue
|
|
}
|
|
atom = self.atomForCommand(command)
|
|
if atom == nil {
|
|
// this was an unknown command,
|
|
// we flag an error and return
|
|
// (note setError will not set the error if there is already one, so we flag internal error
|
|
// in the odd case that an _error is not set.
|
|
self.setError(.internalError, message:"Internal error")
|
|
return nil;
|
|
}
|
|
} else if char == "&" {
|
|
assert(!oneCharOnly, "This should have been handled before")
|
|
if self.currentEnv != nil {
|
|
return list
|
|
} else {
|
|
if let table = self.buildTable(env: nil, firstList: list, isRow: false) {
|
|
return MTMathList(atom: table)
|
|
}
|
|
}
|
|
} else if spacesAllowed && char == " " {
|
|
atom = MTMathAtomFactory.atom(forLatexSymbol: " ")
|
|
} else {
|
|
atom = MTMathAtomFactory.atom(for: String(char))
|
|
|
|
if atom == nil {
|
|
continue
|
|
}
|
|
}
|
|
|
|
assert(atom != nil, "Atom shouldn't be nil")
|
|
|
|
if atom == nil {
|
|
print("wtf atom why nil?")
|
|
return nil
|
|
}
|
|
|
|
list.add(atom!)
|
|
prevAtom = atom
|
|
|
|
if oneCharOnly {
|
|
return list
|
|
}
|
|
}
|
|
|
|
if stop != nil {
|
|
if stop == "}" {
|
|
print("Missing Closing Brace")
|
|
} else {
|
|
print("Expected Character not found: \(stop!)")
|
|
}
|
|
}
|
|
|
|
return list
|
|
}
|
|
|
|
func atomForCommand(_ command:String) -> MTMathAtom? {
|
|
if let atom = MTMathAtomFactory.atom(forLatexSymbol: command) {
|
|
return atom
|
|
}
|
|
if let accent = MTMathAtomFactory.getAccent(withName: command) {
|
|
// The command is an accent
|
|
accent.innerList = self.buildInternal(true)
|
|
return accent;
|
|
} else if command == "frac" {
|
|
// A fraction command has 2 arguments
|
|
let frac = MTFraction()
|
|
frac.numerator = self.buildInternal(true)
|
|
frac.denominator = self.buildInternal(true)
|
|
return frac;
|
|
} else if command == "binom" {
|
|
// A binom command has 2 arguments
|
|
let frac = MTFraction(hasRule: false)
|
|
frac.numerator = self.buildInternal(true)
|
|
frac.denominator = self.buildInternal(true)
|
|
frac.leftDelimiter = "(";
|
|
frac.rightDelimiter = ")";
|
|
return frac;
|
|
} else if command == "sqrt" {
|
|
// A sqrt command with one argument
|
|
let rad = MTRadical()
|
|
let ch = self.getNextCharacter()
|
|
if (ch == "[") {
|
|
// special handling for sqrt[degree]{radicand}
|
|
rad.degree = self.buildInternal(false, stop:"]")
|
|
rad.radicand = self.buildInternal(true)
|
|
} else {
|
|
self.unlookCharacter()
|
|
rad.radicand = self.buildInternal(true)
|
|
}
|
|
return rad;
|
|
} else if command == "left" {
|
|
// Save the current inner while a new one gets built.
|
|
let oldInner = currentInnerAtom
|
|
currentInnerAtom = MTInner()
|
|
currentInnerAtom!.leftBoundary = self.getBoundaryAtom("left")
|
|
if currentInnerAtom!.leftBoundary == nil {
|
|
return nil;
|
|
}
|
|
currentInnerAtom!.innerList = self.buildInternal(false)
|
|
if currentInnerAtom!.rightBoundary == nil {
|
|
// A right node would have set the right boundary so we must be missing the right node.
|
|
let errorMessage = "Missing \\right"
|
|
self.setError(.missingRight, message:errorMessage)
|
|
return nil
|
|
}
|
|
// reinstate the old inner atom.
|
|
let newInner = currentInnerAtom;
|
|
currentInnerAtom = oldInner;
|
|
return newInner;
|
|
} else if command == "overline" {
|
|
// The overline command has 1 arguments
|
|
let over = MTOverLine()
|
|
over.innerList = self.buildInternal(true)
|
|
return over
|
|
} else if command == "underline" {
|
|
// The underline command has 1 arguments
|
|
let under = MTUnderLine()
|
|
under.innerList = self.buildInternal(true)
|
|
return under
|
|
} else if command == "begin" {
|
|
let env = self.readEnvironment()
|
|
if env == nil {
|
|
return nil;
|
|
}
|
|
let table = self.buildTable(env: env, firstList:nil, isRow:false)
|
|
return table
|
|
} else if command == "color" {
|
|
// A color command has 2 arguments
|
|
let mathColor = MTMathColor()
|
|
mathColor.colorString = self.readColor()!
|
|
mathColor.innerList = self.buildInternal(true)
|
|
return mathColor
|
|
} else if command == "colorbox" {
|
|
// A color command has 2 arguments
|
|
let mathColorbox = MTMathColorbox();
|
|
mathColorbox.colorString = self.readColor()!
|
|
mathColorbox.innerList = self.buildInternal(true)
|
|
return mathColorbox
|
|
} else {
|
|
let errorMessage = "Invalid command \\\(command)"
|
|
self.setError(.invalidCommand, message:errorMessage)
|
|
return nil;
|
|
}
|
|
}
|
|
|
|
func readColor() -> String? {
|
|
if !self.expectCharacter("{") {
|
|
// We didn't find an opening brace, so no env found.
|
|
self.setError(.characterNotFound, message:"Missing {")
|
|
return nil;
|
|
}
|
|
|
|
// Ignore spaces and nonascii.
|
|
self.skipSpaces()
|
|
|
|
// a string of all upper and lower case characters.
|
|
var mutable = ""
|
|
while self.hasCharacters {
|
|
let ch = self.getNextCharacter()!
|
|
if (ch == "#" || (ch >= "A" && ch <= "F") || (ch >= "a" && ch <= "f") || (ch >= "0" && ch <= "9")) {
|
|
mutable.append(ch) // appendString:[NSString stringWithCharacters:&ch length:1]];
|
|
} else {
|
|
// we went too far
|
|
self.unlookCharacter()
|
|
break;
|
|
}
|
|
}
|
|
|
|
if !self.expectCharacter("}") {
|
|
// We didn't find an closing brace, so invalid format.
|
|
self.setError(.characterNotFound, message:"Missing }")
|
|
return nil;
|
|
}
|
|
return mutable;
|
|
}
|
|
|
|
func skipSpaces() {
|
|
while self.hasCharacters {
|
|
let ch = self.getNextCharacter()?.asciiValue ?? 0
|
|
if ch < 0x21 || ch > 0x7E {
|
|
// skip non ascii characters and spaces
|
|
continue;
|
|
} else {
|
|
self.unlookCharacter()
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
func stopCommand(_ command: String, list:MTMathList, stop:Character?) -> MTMathList? {
|
|
var fractionCommands: [String:[Character]] {
|
|
[
|
|
"over": [],
|
|
"atop" : [],
|
|
"choose" : [ "(", ")"],
|
|
"brack" : [ "[", "]"],
|
|
"brace" : [ "{", "}"]
|
|
]
|
|
}
|
|
if command == "right" {
|
|
if currentInnerAtom == nil {
|
|
let errorMessage = "Missing \\left";
|
|
self.setError(.missingLeft, message:errorMessage)
|
|
return nil;
|
|
}
|
|
currentInnerAtom!.rightBoundary = self.getBoundaryAtom("right")
|
|
if currentInnerAtom!.rightBoundary == nil {
|
|
return nil;
|
|
}
|
|
// return the list read so far.
|
|
return list
|
|
} else if let _ = fractionCommands[command] {
|
|
var frac:MTFraction! = nil;
|
|
if command == "over" {
|
|
frac = MTFraction()
|
|
} else {
|
|
frac = MTFraction(hasRule: false)
|
|
}
|
|
let delims = fractionCommands[command]!
|
|
if delims.count == 2 {
|
|
frac.leftDelimiter = String(delims[0])
|
|
frac.rightDelimiter = String(delims[1])
|
|
}
|
|
frac.numerator = list;
|
|
frac.denominator = self.buildInternal(false, stop: stop)
|
|
if error != nil {
|
|
return nil;
|
|
}
|
|
let fracList = MTMathList()
|
|
fracList.add(frac)
|
|
return fracList
|
|
} else if command == "\\" || command == "cr" {
|
|
if currentEnv != nil {
|
|
// Stop the current list and increment the row count
|
|
currentEnv!.numRows+=1
|
|
return list
|
|
} else {
|
|
// Create a new table with the current list and a default env
|
|
let table = self.buildTable(env: nil, firstList:list, isRow:true)
|
|
return MTMathList(atom: table!)
|
|
}
|
|
} else if command == "end" {
|
|
if currentEnv != nil {
|
|
let errorMessage = "Missing \\begin";
|
|
self.setError(.missingBegin, message:errorMessage)
|
|
return nil;
|
|
}
|
|
let env = self.readEnvironment()
|
|
if env == nil {
|
|
return nil;
|
|
}
|
|
if env! != currentEnv!.envName {
|
|
let errorMessage = "Begin environment name \(currentEnv!.envName!) does not match end name: \(env!)"
|
|
self.setError(.invalidEnv, message:errorMessage)
|
|
return nil
|
|
}
|
|
// Finish the current environment.
|
|
currentEnv!.ended = true
|
|
return list
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Applies the modifier to the atom. Returns true if modifier applied.
|
|
func applyModifier(_ modifier:String, atom:MTMathAtom?) -> Bool {
|
|
if modifier == "limits" {
|
|
if atom!.type != .largeOperator {
|
|
let errorMessage = "Limits can only be applied to an operator."
|
|
self.setError(.invalidLimits, message:errorMessage)
|
|
} else {
|
|
let op = atom as! MTLargeOperator
|
|
op.limits = true
|
|
}
|
|
return true
|
|
} else if modifier == "nolimits" {
|
|
if atom!.type != .largeOperator {
|
|
let errorMessage = "No limits can only be applied to an operator."
|
|
self.setError(.invalidLimits, message:errorMessage)
|
|
return true
|
|
} else {
|
|
let op = atom as! MTLargeOperator
|
|
op.limits = false
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
func setError(_ code:MTParseErrors, message:String) {
|
|
// Only record the first error.
|
|
if error == nil {
|
|
error = NSError(domain: MTParseError, code: code.rawValue, userInfo: [ NSLocalizedDescriptionKey : message ])
|
|
}
|
|
}
|
|
|
|
func atom(forCommand command: String) -> MTMathAtom? {
|
|
if let atom = MTMathAtomFactory.atom(forLatexSymbol: command) {
|
|
return atom
|
|
}
|
|
|
|
if let accent = MTMathAtomFactory.getAccent(withName: command) {
|
|
accent.innerList = self.buildInternal(true)
|
|
return accent
|
|
} else if command == "frac" {
|
|
let frac = MTFraction()
|
|
frac.numerator = self.buildInternal(true)
|
|
frac.denominator = self.buildInternal(true)
|
|
return frac
|
|
} else if command == "binom" {
|
|
let frac = MTFraction(hasRule: false)
|
|
frac.numerator = self.buildInternal(true)
|
|
frac.denominator = self.buildInternal(true)
|
|
frac.leftDelimiter = "("
|
|
frac.rightDelimiter = ")"
|
|
return frac
|
|
} else if command == "sqrt" {
|
|
let rad = MTRadical()
|
|
let char = self.getNextCharacter()
|
|
|
|
if char == "[" {
|
|
rad.degree = self.buildInternal(false, stop: "]")
|
|
rad.radicand = self.buildInternal(true)
|
|
} else {
|
|
self.unlookCharacter()
|
|
rad.radicand = self.buildInternal(true)
|
|
}
|
|
return rad
|
|
} else if command == "left" {
|
|
let oldInner = self.currentInnerAtom
|
|
self.currentInnerAtom = MTInner()
|
|
self.currentInnerAtom?.leftBoundary = self.getBoundaryAtom("left")
|
|
if self.currentInnerAtom?.leftBoundary == nil {
|
|
return nil
|
|
}
|
|
self.currentInnerAtom!.innerList = self.buildInternal(false)
|
|
if self.currentInnerAtom?.rightBoundary == nil {
|
|
print("Missing \\right")
|
|
return nil
|
|
}
|
|
let newInner = self.currentInnerAtom
|
|
currentInnerAtom = oldInner
|
|
return newInner
|
|
} else if command == "overline" {
|
|
let over = MTOverLine()
|
|
over.innerList = self.buildInternal(true)
|
|
|
|
return over
|
|
} else if command == "underline" {
|
|
let under = MTUnderLine()
|
|
under.innerList = self.buildInternal(true)
|
|
|
|
return under
|
|
} else if command == "begin" {
|
|
if let env = self.readEnvironment() {
|
|
let table = self.buildTable(env: env, firstList: nil, isRow: false)
|
|
return table
|
|
} else {
|
|
return nil
|
|
}
|
|
} else {
|
|
print("Invalid Command")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// func stop(command: String, list: MTMathList, stopChar: Character) -> MTMathList? {
|
|
// let fractionCommands = [
|
|
// "over": [],
|
|
// "atop": [],
|
|
// "choose": ["(", ")"],
|
|
// "brack": ["[", "]"],
|
|
// "brace": ["{", "}"]
|
|
// ]
|
|
//
|
|
// if command == "right" {
|
|
// if self.currentInnerAtom == nil {
|
|
// print("missing left")
|
|
// return nil
|
|
// }
|
|
//
|
|
// if let rightBoundary = self.getBoundaryAtom("right") {
|
|
// self.currentInnerAtom!.rightBoundary = rightBoundary
|
|
//
|
|
// return list
|
|
// } else {
|
|
// return nil
|
|
// }
|
|
// } else if let delims = fractionCommands[command] {
|
|
// let frac: MTFraction
|
|
// if command == "over" {
|
|
// frac = MTFraction()
|
|
// } else {
|
|
// frac = MTFraction(hasRule: false)
|
|
// }
|
|
//
|
|
// if delims.count == 2 {
|
|
// frac.leftDelimiter = delims[0]
|
|
// frac.rightDelimiter = delims[1]
|
|
// }
|
|
//
|
|
// frac.numerator = list
|
|
// frac.denominator = self.buildInternal(false, stopChar: stopChar)
|
|
//
|
|
// let fracList = MTMathList()
|
|
// fracList.add(frac)
|
|
// return fracList
|
|
// } else if command == "\\" || command == "cr" {
|
|
// if currentEnv != nil {
|
|
// currentEnv!.numRows += 1
|
|
// return list
|
|
// } else {
|
|
// if let table = self.buildTable(env: nil, firstList: list, isRow: true) {
|
|
// return MTMathList(atoms: [table])
|
|
// } else {
|
|
// return nil
|
|
// }
|
|
// }
|
|
// } else if command == "end" {
|
|
// if self.currentEnv == nil {
|
|
// print("Missing \\begin")
|
|
// return nil
|
|
// }
|
|
//
|
|
// if let env = self.readEnvironment() {
|
|
// if env != self.currentEnv?.envName {
|
|
// print("Begin environment name \(currentEnv!.envName!) does not match end name: \(env)")
|
|
// return nil
|
|
// }
|
|
//
|
|
// currentEnv?.ended = true
|
|
//
|
|
// return list
|
|
// } else {
|
|
// return nil
|
|
// }
|
|
// }
|
|
// return nil
|
|
// }
|
|
|
|
func readEnvironment() -> String? {
|
|
if !self.expectCharacter("{") {
|
|
// We didn't find an opening brace, so no env found.
|
|
print("Missing {")
|
|
return nil
|
|
}
|
|
|
|
self.skipSpace()
|
|
let env = self.readString()
|
|
|
|
if !self.expectCharacter("}") {
|
|
// We didn"t find an closing brace, so invalid format.
|
|
print("Missing {")
|
|
return nil;
|
|
}
|
|
return env
|
|
}
|
|
|
|
func expectCharacter(_ char: Character) -> Bool {
|
|
self.skipSpace()
|
|
|
|
if self.hasCharacters {
|
|
let nextChar = self.getNextCharacter()!
|
|
|
|
if nextChar == char {
|
|
return true
|
|
} else {
|
|
self.unlookCharacter()
|
|
return false
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func buildTable(env: String?, firstList: MTMathList?, isRow: Bool) -> MTMathAtom? {
|
|
// Save the current env till an new one gets built.
|
|
let oldEnv = self.currentEnv
|
|
|
|
currentEnv = MTEnvProperties(name: env)
|
|
|
|
var currentRow = 0
|
|
var currentCol = 0
|
|
|
|
var rows = [[MTMathList]]()
|
|
|
|
if firstList != nil {
|
|
rows[currentRow][currentCol] = firstList!
|
|
|
|
if isRow {
|
|
currentEnv?.numRows += 1
|
|
currentRow += 1
|
|
} else {
|
|
currentCol += 1
|
|
}
|
|
}
|
|
|
|
while !currentEnv!.ended && self.hasCharacters {
|
|
if let list = self.buildInternal(false) {
|
|
rows[currentRow][currentCol] = list
|
|
currentCol += 1
|
|
if self.currentEnv!.numRows > currentRow {
|
|
currentRow = self.currentEnv!.numRows
|
|
currentCol = 0
|
|
}
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
if !currentEnv!.ended && currentEnv?.envName == nil {
|
|
print("Missing \\end")
|
|
return nil
|
|
}
|
|
|
|
if let table = MTMathAtomFactory.table(withEnvironment: currentEnv?.envName, rows: rows) {
|
|
self.currentEnv = oldEnv
|
|
return table
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func getBoundaryAtom(_ delimiterType: String) -> MTMathAtom? {
|
|
let delim = self.readDelimiter()
|
|
if delim == nil {
|
|
assertionFailure("Missing delimiter for \(delimiterType)")
|
|
return nil
|
|
}
|
|
let boundary = MTMathAtomFactory.boundary(forDelimiter: delim!)
|
|
if boundary == nil {
|
|
assertionFailure("Invalid delimiter for \(delimiterType): \(delim!)")
|
|
return nil
|
|
}
|
|
return boundary
|
|
}
|
|
|
|
func readDelimiter() -> String? {
|
|
self.skipSpace()
|
|
|
|
while self.hasCharacters {
|
|
let char = self.getNextCharacter()!
|
|
|
|
if char == "\\" {
|
|
let command = self.readCommand()
|
|
if command == "|" {
|
|
return "||"
|
|
}
|
|
return command
|
|
} else {
|
|
return String(char)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func skipSpace() {
|
|
while self.hasCharacters {
|
|
let char = self.getNextCharacter()
|
|
let asciiCharacterSet = CharacterSet(charactersIn: UnicodeScalar(0x21)...UnicodeScalar(0x7e))
|
|
if String(char!).rangeOfCharacter(from: asciiCharacterSet) != nil {
|
|
self.unlookCharacter()
|
|
return
|
|
} else {
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func readCommand() -> String {
|
|
let singleChars = Array("{}$#%_| ,>;!\\")
|
|
if self.hasCharacters {
|
|
if let char = self.getNextCharacter() {
|
|
if let _ = singleChars.firstIndex(of: char) {
|
|
return String(char)
|
|
} else {
|
|
self.unlookCharacter()
|
|
}
|
|
}
|
|
}
|
|
|
|
return self.readString()
|
|
}
|
|
|
|
func readString() -> String {
|
|
// a string of all upper and lower case characters.
|
|
var output = ""
|
|
while self.hasCharacters {
|
|
if let char = self.getNextCharacter() {
|
|
if char.isLowercase || char.isUppercase {
|
|
output.append(char)
|
|
} else {
|
|
self.unlookCharacter()
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return output
|
|
}
|
|
}
|