Update

Author: odow

docs/src/submodules/FileFormats/LP.md

@@ -193,7 +193,7 @@ tokens, but they're an outlier.
 In general, an identifier may contain the letters a-z, A-Z, the digits 0-9, and
 the characters ```!"#\$%&()/,.;?@_'`|~```.
 
-Additional solvers put additional restrictictions:
+Additional solvers put additional restrictions:
 
  * In (all?) solvers except Gurobi, the identifier must not start with a digit
    or a `.` (in Gurobi, identifiers must be separated by whitespace)

src/FileFormats/LP/read.jl

@@ -48,39 +48,35 @@ function Base.read!(io::IO, model::Model{T}) where {T}
     end
     state = _LexerState(io)
     cache = _ReadCache(model)
-    keyword = :UNKNOWN
     while (token = peek(state, _Token)) !== nothing
-        if token.kind == _TOKEN_KEYWORD
-            _ = read(state, _Token)
-            keyword = Symbol(token.value)
-        elseif token.kind == _TOKEN_NEWLINE
+        if token.kind == _TOKEN_NEWLINE
             _ = read(state, _Token, _TOKEN_NEWLINE)
-        elseif keyword == :MINIMIZE
+            continue
+        end
+        keyword = _parse_keyword(state, cache)
+        if keyword == :MINIMIZE
             MOI.set(cache.model, MOI.ObjectiveSense(), MOI.MIN_SENSE)
             _parse_objective(state, cache)
-            keyword = :UNKNOWN
         elseif keyword == :MAXIMIZE
             MOI.set(cache.model, MOI.ObjectiveSense(), MOI.MAX_SENSE)
             _parse_objective(state, cache)
-            keyword = :UNKNOWN
         elseif keyword == :CONSTRAINTS
-            _parse_constraint(state, cache)
+            while _parse_constraint(state, cache)
+            end
         elseif keyword == :BINARY
-            x = _parse_identifier(state, cache)
-            MOI.add_constraint(cache.model, x, MOI.ZeroOne())
+            while _parse_binary(state, cache)
+            end
         elseif keyword == :INTEGER
-            x = _parse_identifier(state, cache)
-            MOI.add_constraint(cache.model, x, MOI.Integer())
+            while _parse_integer(state, cache)
+            end
         elseif keyword == :BOUNDS
-            _parse_bound_expression(state, cache)
+            while _parse_bound_expression(state, cache)
+            end
         elseif keyword == :SOS
-            _parse_constraint(state, cache)
+            while _parse_constraint(state, cache)
+            end
         elseif keyword == :END
-            _throw_parse_error(
-                state,
-                token,
-                "No file contents are allowed after `end`.",
-            )
+            break
         else
             _throw_parse_error(
                 state,
@@ -89,9 +85,11 @@ function Base.read!(io::IO, model::Model{T}) where {T}
             )
         end
     end
-    # if keyword != :END
-    #     TODO(odow): decide if we should throw an error here.
-    # end
+    _skip_newlines(state)
+    if (p = peek(state, _Token)) !== nothing
+        msg = "No file contents are allowed after `end`."
+        _throw_parse_error(state, p, msg)
+    end
     for x in cache.variable_with_default_bound
         MOI.add_constraint(model, x, MOI.GreaterThan(0.0))
     end
@@ -164,7 +162,6 @@ Hopefully they're all self-explanatory.
 """
 @enum(
     _TokenKind,
-    _TOKEN_KEYWORD,
     _TOKEN_IDENTIFIER,
     _TOKEN_NUMBER,
     _TOKEN_ADDITION,
@@ -190,7 +187,6 @@ This dictionary makes `_TokenKind` to a string that is used when printing error
 messages. The string must complete the sentence "We expected this token to be ".
 """
 const _KIND_TO_MSG = Dict{_TokenKind,String}(
-    _TOKEN_KEYWORD => "a keyword",
     _TOKEN_IDENTIFIER => "a variable name",
     _TOKEN_NUMBER => "a number",
     _TOKEN_ADDITION => "the symbol `+`",
@@ -372,59 +368,6 @@ function Base.peek(state::_LexerState, ::Type{_Token}, n::Int = 1)
             return nothing
         end
         push!(state.peek_tokens, token)
-        if token.kind != _TOKEN_IDENTIFIER
-            continue
-        end
-        # Here we have a _TOKEN_IDENTIFIER. But if it is not preceeded by a
-        # _TOKEN_NEWLINE, it cannot be a _TOKEN_KEYWORD.
-        if !_nothing_or_newline(_prior_token(state))
-            continue
-        end
-        # It might be a _TOKEN_KEYWORD.
-        (kw = _case_insenstive_identifier_to_keyword(token.value))
-        if kw !== nothing
-            # The token matches a single word keyword. All keywords are followed
-            # by a new line, or an EOF.
-            t = _peek_inner(state)
-            if _nothing_or_newline(t)
-                state.peek_tokens[end] = _Token(_TOKEN_KEYWORD, kw, token.pos)
-            end
-            if t !== nothing
-                push!(state.peek_tokens, t)
-            end
-            continue
-        end
-        # There are two keyword that contain whitespace: `subject to` and
-        # `such that`
-        for (a, b) in ("subject" => "to", "such" => "that")
-            if !_compare_case_insenstive(token, a)
-                continue
-            end
-            # This _might_ be `subject to`, or it might just be a variable
-            # named `subject`, like `obj:\n subject\n`.
-            token_b = _peek_inner(state)
-            if token_b === nothing
-                # The next token is EOF. Nothing to do here.
-                break
-            elseif !_compare_case_insenstive(token_b, b)
-                # The second token doesn't match. Store `token_b` and break
-                push!(state.peek_tokens, token_b)
-                break
-            end
-            # We have something that matches (a, b), but a TOKEN_KEYWORD needs
-            # to be followed by a new line.
-            token_nl = _peek_inner(state)
-            if _nothing_or_newline(token_nl)
-                state.peek_tokens[end] =
-                    _Token(_TOKEN_KEYWORD, "CONSTRAINTS", token.pos)
-            else
-                push!(state.peek_tokens, token_b)
-            end
-            if token_nl !== nothing
-                push!(state.peek_tokens, token_nl)
-            end
-            break
-        end
     end
     return state.peek_tokens[n]
 end
@@ -523,6 +466,33 @@ function _next_non_newline(state::_LexerState)
     end
 end
 
+function _parse_keyword(state::_LexerState, cache::_ReadCache)::Symbol
+    token = read(state, _Token, _TOKEN_IDENTIFIER)
+    kw = _case_insenstive_identifier_to_keyword(token.value)
+    if kw !== nothing
+        return Symbol(kw)
+    end
+    # Check `subject to`
+    if _compare_case_insenstive(token, "subject")
+        token_b = peek(state, _Token)
+        if _compare_case_insenstive(token_b, "to")
+            _ = read(state, _Token, _TOKEN_IDENTIFIER)
+            return :CONSTRAINTS
+        end
+    elseif _compare_case_insenstive(token, "such")
+        token_b = peek(state, _Token)
+        if _compare_case_insenstive(token_b, "that")
+            _ = read(state, _Token, _TOKEN_IDENTIFIER)
+            return :CONSTRAINTS
+        end
+    end
+    return _throw_parse_error(
+        state,
+        token,
+        "Expected a keyword.",
+    )
+end
+
 # <identifier> :== "string"
 #
 #   There _are_ rules to what an identifier can be. We handle these when lexing.
@@ -637,10 +607,16 @@ function _parse_quadratic_expression(
     while (p = peek(state, _Token)) !== nothing
         if p.kind == _TOKEN_ADDITION
             p = read(state, _Token)
-            push!(f.quadratic_terms, _parse_quadratic_term(state, cache, prefix))
+            push!(
+                f.quadratic_terms,
+                _parse_quadratic_term(state, cache, prefix),
+            )
         elseif p.kind == _TOKEN_SUBTRACTION
             p = read(state, _Token)
-            push!(f.quadratic_terms, _parse_quadratic_term(state, cache, -prefix))
+            push!(
+                f.quadratic_terms,
+                _parse_quadratic_term(state, cache, -prefix),
+            )
         elseif p.kind == _TOKEN_NEWLINE
             _ = read(state, _Token)
         elseif p.kind == _TOKEN_CLOSE_BRACKET
@@ -782,10 +758,7 @@ function _parse_expression(state::_LexerState, cache::_ReadCache{T}) where {T}
             p = read(state, _Token)
             _add_to_expression!(f, _parse_term(state, cache, -one(T)))
         elseif p.kind == _TOKEN_NEWLINE
-            if _next_token_is(state, _TOKEN_KEYWORD, 2)
-                break
-            end
-            _ = read(state, _Token)
+            _ = read(state, _Token, _TOKEN_NEWLINE)
         else
             break
         end
@@ -855,30 +828,40 @@ function _parse_set_prefix(state, cache)
     end
 end
 
-# <name> :== [<identifier> :]
+# <name> :== <identifier> :
+
+function _is_name(state::_LexerState)
+    return _next_token_is(state, _TOKEN_IDENTIFIER, 1) &&
+           _next_token_is(state, _TOKEN_COLON, 2)
+end
+
 function _parse_name(state::_LexerState, cache::_ReadCache)
-    _skip_newlines(state)
-    if _next_token_is(state, _TOKEN_IDENTIFIER, 1) &&
-       _next_token_is(state, _TOKEN_COLON, 2)
-        name = read(state, _Token)
-        _ = read(state, _Token)  # Skip :
-        return name.value
-    end
-    return nothing
+    name = read(state, _Token, _TOKEN_IDENTIFIER)
+    _ = read(state, _Token, _TOKEN_COLON)
+    return name.value
 end
 
 # <objective> :== <name> [<expression>]
 function _parse_objective(state::_LexerState, cache::_ReadCache)
     _ = _parse_name(state, cache)
     _skip_newlines(state)
-    if _next_token_is(state, _TOKEN_KEYWORD)
-        return  # A line like `obj:\nsubject to`
-    end
     f = _parse_expression(state, cache)
     MOI.set(cache.model, MOI.ObjectiveFunction{typeof(f)}(), f)
     return
 end
 
+function _parse_integer(state::_LexerState, cache::_ReadCache)
+    x = _parse_identifier(state, cache)
+    MOI.add_constraint(cache.model, x, MOI.Integer())
+    return true
+end
+
+function _parse_binary(state::_LexerState, cache::_ReadCache)
+    x = _parse_identifier(state, cache)
+    MOI.add_constraint(cache.model, x, MOI.ZeroOne())
+    return true
+end
+
 function _add_bound(
     cache::_ReadCache,
     x::MOI.VariableIndex,
@@ -922,21 +905,21 @@ function _parse_bound_expression(state, cache)
         x = _parse_identifier(state, cache)
         set = _parse_set_suffix(state, cache)
         _add_bound(cache, x, set)
-        return
-    end
-    # `a op x` or `a op x op b`
-    lhs_set = _parse_set_prefix(state, cache)
-    x = _parse_identifier(state, cache)
-    _add_bound(cache, x, lhs_set)
-    if _next_token_is(state, _TOKEN_GREATER_THAN) ||
-       _next_token_is(state, _TOKEN_LESS_THAN) ||
-       _next_token_is(state, _TOKEN_EQUAL_TO)  # `a op x op b`
-        # We don't add MOI.Interval constraints to follow JuMP's convention of
-        # separate bounds.
-        rhs_set = _parse_set_suffix(state, cache)
-        _add_bound(cache, x, rhs_set)
+    else
+        # `a op x` or `a op x op b`
+        lhs_set = _parse_set_prefix(state, cache)
+        x = _parse_identifier(state, cache)
+        _add_bound(cache, x, lhs_set)
+        if _next_token_is(state, _TOKEN_GREATER_THAN) ||
+        _next_token_is(state, _TOKEN_LESS_THAN) ||
+        _next_token_is(state, _TOKEN_EQUAL_TO)  # `a op x op b`
+            # We don't add MOI.Interval constraints to follow JuMP's convention of
+            # separate bounds.
+            rhs_set = _parse_set_suffix(state, cache)
+            _add_bound(cache, x, rhs_set)
+        end
     end
-    return
+    return true
 end
 
 function _is_sos_constraint(state)
@@ -1022,11 +1005,15 @@ function _parse_constraint_indicator(
 end
 
 # <constraint> :==
-#     <name> <expression> <set-suffix>
-#   | <name> <constraint-sos>
-#   | <name> <constraint-indicator>
+#     [<name>] <expression> <set-suffix>
+#   | [<name>] <constraint-sos>
+#   | [<name>] <constraint-indicator>
 function _parse_constraint(state::_LexerState, cache::_ReadCache)
-    name = _parse_name(state, cache)
+    name = if _is_name(state)
+        _parse_name(state, cache)
+    else
+        nothing
+    end
     # Check if this is an SOS constraint
     c = if _is_sos_constraint(state)
         _parse_constraint_sos(state, cache)
@@ -1040,5 +1027,5 @@ function _parse_constraint(state::_LexerState, cache::_ReadCache)
     if name !== nothing
         MOI.set(cache.model, MOI.ConstraintName(), c, name)
     end
-    return
+    return true
 end