def parse(self, rules, file, dumpLine=False, defaultRule=None):
self.rules = {rule.Id: rule for rule in rules}
lineNum = 1
ineqId = 1
lines = iter(file)
defaultIdSize = 1
# the first line is not allowed to be comment line or empty but must be the header
if hasattr(self, "parseHeader"):
try:
self.parseHeader(next(lines))
except ParseError as e:
e.line = lineNum
raise e
except StopIteration:
raise ParseError("Expected Header.")
else:
lineNum = 0
for line in lines:
idSize = defaultIdSize
lineNum += 1
if dumpLine:
print("line %03d: %s" % (lineNum, line.rstrip()))
if not self.isEmpty(line):
line = line.rstrip()
ruleId = line.split(" ")[0]
idSize = len(ruleId)
try:
rule = self.rules[line[0:idSize]]
except KeyError as e:
if defaultRule is None:
raise ParseError("Unsupported rule '%s'" %
(line[0:idSize]),
line=lineNum)
else:
rule = defaultRule
idSize = 0
try:
step = rule.parse(line[idSize:], self.context)
step.lineInFile = lineNum
numConstraints = step.numConstraints()
yield step
for listener in self.context.addIneqListener:
listener(range(ineqId, ineqId + numConstraints),
self.context)
ineqId += numConstraints
except veripb.ParseError as e:
e.line = lineNum
if e.column is not None:
e.column += idSize
raise e
def __next__(self):
try:
a = next(self.iterator)
except StopIteration:
raise ParseError("Expected %s."%\
(",".join(map(lambda x: "'%s'"%(str(x)), self.endWords))))
if a in self.endWords:
self.lastWord = a
raise StopIteration
a = int(a)
try:
b = next(self.iterator)
except StopIteration:
raise ParseError("Expected literal.")
b = self.parseLit(b)
return (a, b)
def raiseParseError(self, wordNum, error):
column = None
if wordNum >= len(self.words) or wordNum < 0:
column = len(self.line)
else:
for idx, match in enumerate(
re.finditer(r" *(?P<word>[^ ]+)", self.line)):
if idx == wordNum:
column = match.start("word")
assert (column is not None)
column += 1
raise ParseError(error, column=column)
def parse(self, rules, file, dumpLine=False, defaultRule=None):
self.parseContext.rules = rules_to_dict(rules, defaultRule)
with LineParser(file) as lines:
defaultIdSize = 1
# the first line is not allowed to be comment line or empty but must be the header
if hasattr(self, "parseHeader"):
try:
self.parseHeader(next(lines))
except ParseError as e:
e.line = lines.iter.getLine()
raise e
except StopIteration:
raise ParseError("Expected Header.")
for words in lines:
if dumpLine:
print(
"line %03d: %s" % (lines.iter.getLine(),
lines.iter.getLineText().rstrip()))
ruleId = self.getRuleId(words)
if ruleId is not None:
try:
rule = self.parseContext.rules[ruleId]
except KeyError as e:
rule = self.parseContext.rules.get("", None)
if rule is not None:
words.putback(ruleId)
else:
raise ValueError("Unsupported rule '%s'" %
(ruleId))
step = rule.parse(words, self.parseContext.context)
step.lineInFile = lines.iter.getLine()
yield step
self.parseContext = step.newParseContext(self.parseContext)
numConstraints = step.numConstraints()
if numConstraints > 0:
oldFree = self.parseContext.firstFreeId
newFree = oldFree + numConstraints
self.parseContext.firstFreeId = newFree
for listener in self.parseContext.addIneqListener:
listener(range(oldFree, newFree),
self.parseContext.context)
def parse(self, formulaFile):
lines = iter(enumerate(formulaFile, start=1))
numVar, numC = None, None
lineNum = 0
for lineNum, line in lines:
if not self.isEmpty(line):
try:
numVar, numC = self.parseHeader(line)
except ParseError as e:
e.line = lineNum
raise e
break
if numVar is None:
raise ParseError("Expected header.", line=lineNum + 1)
constraints = list()
for lineNum, line in lines:
try:
constraints.extend(self.parseLine(line.rstrip()))
except ParseError as e:
e.line = lineNum
raise e
if self.ineqFactory.numVars() != numVar:
logging.warning("Number of variables did not match,"\
" using %i instead."%(self.ineqFactory.numVars()))
return {
"numVariables": numVar,
"numConstraints": numC,
"constraints": constraints,
"objective": None
}
def parse(self, formulaFile):
lines = iter(enumerate(formulaFile, start=1))
self.objective = None
try:
lineNum, line = next(lines)
except StopIteration:
raise ParseError("Expected header.", line=1)
try:
numVar, numC = self.parseHeader(line)
except ParseError as e:
e.line = lineNum
raise e
constraints = list()
for lineNum, line in lines:
try:
constraints.extend(self.parseLine(line.rstrip()))
except ParseError as e:
e.line = lineNum
raise e
if self.ineqFactory.numVars() != numVar:
logging.warn("Number of variables did not match,"\
" using %i instead."%(self.ineqFactory.numVars()))
if self.objective is False:
self.objective = None
return {
"numVariables": numVar,
"numConstraints": numC,
"constraints": constraints,
"objective": self.objective
}
def parse(cls, line, context):
subContexts = SubContext.setup(context)
if not subContexts:
raise ParseError("No subcontext to end here.")
return cls(subContexts.getCurrent())
def raiseParseError(self, error):
raise ParseError(error, self.iter.getFileName(), self.iter.getLine(),
self.iter.getColumn())