public Language<?> pasteTokens(Language<?> t1, Language<?> t2) {
// Paste the tokens and run the resulting string through the
// lexer.
String str = t1.getTokenText() + t2.getTokenText();
StringReader sr = new StringReader(str);
CLexer lexer = new CLexer(sr);
Syntax pasted;
Syntax next;
try {
pasted = lexer.yylex();
next = lexer.yylex();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException();
}
// If the token-paste was successful, the next token will be an
// EOF.
if (next.kind() == Kind.EOF) {
return pasted.toLanguage();
} else {
return null;
}
}
@Override
public Syntax getSyntax() {
int[] input = new int[] {Syntax.StringType() | Syntax.TurtleType(), Syntax.StringType()};
int output = Syntax.BooleanType();
return Syntax.reporterSyntax(input, output);
}
private void fetchTokenFor_digit() {
unfetch();
final int last = p;
final int num = scanUnsignedNumber();
if (num < 0 || num > Config.MAX_BACKREF_NUM) { // goto skip_backref
} else if (syntax.opDecimalBackref() && (num <= env.numMem || num <= 9)) {
/* This spec. from GNU regex */
if (syntax.strictCheckBackref()) {
if (num > env.numMem || env.memNodes == null || env.memNodes[num] == null) {
throw new ValueException(ERR_INVALID_BACKREF);
}
}
token.type = TokenType.BACKREF;
token.setBackrefRef(num);
return;
}
if (c == '8' || c == '9') {
/* normal char */
// skip_backref:
p = last;
inc();
return;
}
p = last;
fetchTokenFor_zero(); /* fall through */
}
@SuppressWarnings("fallthrough")
/* \M-, \C-, \c, or \... */
private int fetchEscapedValue() {
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_ESCAPE);
}
fetch();
switch (c) {
case 'M':
if (syntax.op2EscCapitalMBarMeta()) {
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_META);
}
fetch();
if (c != '-') {
throw new SyntaxException(ERR_META_CODE_SYNTAX);
}
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_META);
}
fetch();
if (c == syntax.metaCharTable.esc) {
c = fetchEscapedValue();
}
c = ((c & 0xff) | 0x80);
} else {
fetchEscapedValueBackSlash();
}
break;
case 'C':
if (syntax.op2EscCapitalCBarControl()) {
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_CONTROL);
}
fetch();
if (c != '-') {
throw new SyntaxException(ERR_CONTROL_CODE_SYNTAX);
}
fetchEscapedValueControl();
} else {
fetchEscapedValueBackSlash();
}
break;
case 'c':
if (syntax.opEscCControl()) {
fetchEscapedValueControl();
}
/* fall through */
default:
fetchEscapedValueBackSlash();
} // switch
return c; // ???
}
public String details() {
return "DotMethodCallExp("
+ "methodName="
+ Syntax.detailsome(this.methodName)
+ " "
+ "subpat="
+ Syntax.detailsome(this.subpat)
+ ")";
}
public void defineSyntax(CTX ctx, Syntax[] syndef) {
for (Syntax syn : syndef) {
if (syn.rule != null) {
syn.syntaxRuleNULL = new ArrayList<Token>();
parseSyntaxRule(ctx, syn.rule, 0, syn.syntaxRuleNULL);
}
this.syntaxMapNN.put(syn.kw, syn);
}
}
public String details() {
return "ClsPatDef("
+ "id="
+ Syntax.detailsome(this.id)
+ " "
+ "formals="
+ "["
+ Syntax.sepDetails(this.formals, ",")
+ "]"
+ " "
+ "body="
+ Syntax.detailsome(this.body)
+ ")";
}
private void possessiveCheck() {
if (left()
&& peekIs('+')
&& (syntax.op2PlusPossessiveRepeat() && token.type != TokenType.INTERVAL
|| syntax.op2PlusPossessiveInterval() && token.type == TokenType.INTERVAL)) {
fetch();
token.setRepeatGreedy(true);
token.setRepeatPossessive(true);
} else {
token.setRepeatGreedy(true);
token.setRepeatPossessive(false);
}
}
public FunDef getDef(Exp[] args, String funName, Syntax syntax) {
// Compute signature first. It makes debugging easier.
final String signature = syntax.getSignature(funName, Category.Unknown, ExpBase.getTypes(args));
// Resolve function by its upper-case name first. If there is only one
// function with that name, stop immediately. If there is more than
// function, use some custom method, which generally involves looking
// at the type of one of its arguments.
List<Resolver> resolvers = funTable.getResolvers(funName, syntax);
assert resolvers != null;
final List<Resolver.Conversion> conversionList = new ArrayList<Resolver.Conversion>();
int minConversionCost = Integer.MAX_VALUE;
List<FunDef> matchDefs = new ArrayList<FunDef>();
List<Resolver.Conversion> matchConversionList = null;
for (Resolver resolver : resolvers) {
conversionList.clear();
FunDef def = resolver.resolve(args, this, conversionList);
if (def != null) {
int conversionCost = sumConversionCost(conversionList);
if (conversionCost < minConversionCost) {
minConversionCost = conversionCost;
matchDefs.clear();
matchDefs.add(def);
matchConversionList = new ArrayList<Resolver.Conversion>(conversionList);
} else if (conversionCost == minConversionCost) {
matchDefs.add(def);
} else {
// ignore this match -- it required more coercions than
// other overloadings we've seen
}
}
}
switch (matchDefs.size()) {
case 0:
throw MondrianResource.instance().NoFunctionMatchesSignature.ex(signature);
case 1:
break;
default:
final StringBuilder buf = new StringBuilder();
for (FunDef matchDef : matchDefs) {
if (buf.length() > 0) {
buf.append(", ");
}
buf.append(matchDef.getSignature());
}
throw MondrianResource.instance()
.MoreThanOneFunctionMatchesSignature
.ex(signature, buf.toString());
}
final FunDef matchDef = matchDefs.get(0);
for (Resolver.Conversion conversion : matchConversionList) {
conversion.checkValid();
conversion.apply(this, Arrays.asList(args));
}
return matchDef;
}
/**
* Initializes the renderer.
*
* @param g graphics reference
* @param pos current text position
*/
private void init(final Graphics g, final int pos) {
font = dfont;
color = Color.black;
syntax.init();
text.init();
x = off;
y = off + fontH - pos - 2;
if (g != null) g.setFont(font);
}
public Syntax getSyntax() {
return Syntax.commandSyntax(
new int[] {
Syntax.StringType(),
Syntax.NumberType(),
Syntax.NumberType(),
Syntax.NumberType(),
Syntax.NumberType(),
Syntax.NumberType(),
Syntax.NumberType()
});
}
@Nullable
public static Syntax find(@Nullable String name) {
if (name == null) {
return null;
}
try {
return Syntax.valueOf(name.toUpperCase());
} catch (IllegalArgumentException iae) {
return null;
}
}
private void greedyCheck() {
if (left() && peekIs('?') && syntax.opQMarkNonGreedy()) {
fetch();
token.setRepeatGreedy(false);
token.setRepeatPossessive(false);
} else {
possessiveCheck();
}
}
private void fetchTokenInCCFor_x() {
if (!left()) {
return;
}
final int last = p;
if (peekIs('{') && syntax.opEscXBraceHex8()) {
inc();
final int num = scanUnsignedHexadecimalNumber(8);
if (num < 0) {
throw new ValueException(ERR_TOO_BIG_WIDE_CHAR_VALUE);
}
if (left()) {
final int c2 = peek();
if (EncodingHelper.isXDigit(c2)) {
throw new ValueException(ERR_TOO_LONG_WIDE_CHAR_VALUE);
}
}
if (p > last + 1 && left() && peekIs('}')) {
inc();
token.type = TokenType.CODE_POINT;
token.setCode(num);
} else {
/* can't read nothing or invalid format */
p = last;
}
} else if (syntax.opEscXHex2()) {
int num = scanUnsignedHexadecimalNumber(2);
if (num < 0) {
throw new ValueException(ERR_TOO_BIG_NUMBER);
}
if (p == last) {
/* can't read nothing. */
num = 0; /* but, it's not error */
}
token.type = TokenType.RAW_BYTE;
token.setC(num);
}
}
private void fetchTokenFor_openBrace() {
switch (fetchRangeQuantifier()) {
case 0:
greedyCheck();
break;
case 2:
if (syntax.fixedIntervalIsGreedyOnly()) {
possessiveCheck();
} else {
greedyCheck();
}
break;
default: /* 1 : normal char */
} // inner switch
}
/**
* Created by Kevin on 2015-06-08. A statement that sets the value of an existing {@link Variable}
*/
public class SetStatement extends Statement<Object> {
public static final Syntax SYNTAX =
Syntax.builder()
.customPredicate(
new Predicate<String>() {
@Override
public boolean apply(String input) {
String[] split = StringParser.instance().parseSplit(input, " = ");
return split.length == 2
&& !split[0].trim().isEmpty()
&& !split[1]
.trim()
.isEmpty(); // Basically just check if something exists on both sides of
// an operator
}
})
.arguments(
Arguments.of(
GenericArguments.withNameAndFlags(
"VariableName",
new int[] {Argument.NO_RESOLVE, Argument.CREATE_VARIABLE_IF_NONE})))
.arguments(
Arguments.of(
GenericArguments.withNameAndFlags(
"VariableName", Argument.NO_RESOLVE, Argument.CREATE_VARIABLE_IF_NONE),
"=",
GenericArguments.withName("Value")))
.build();
@Override
public Syntax getSyntax() {
return SYNTAX;
}
@Override
public Result<Object> run(Context ctx) {
MutableValue mutableValue =
((ValueContainer) ctx.getContainer("VariableName")).resolveValue(ctx); // Set a variable
Literal value = ctx.getLiteral("Value");
mutableValue.setDatum(value);
return Result.builder()
.success()
.result(value)
.build(); // We don't use get here because because we don't want to disturb non-literal data
}
}
private void fetchTokenInCCFor_digit() {
if (syntax.opEscOctal3()) {
unfetch();
final int last = p;
int num = scanUnsignedOctalNumber(3);
if (num < 0) {
throw new ValueException(ERR_TOO_BIG_NUMBER);
}
if (p == last) {
/* can't read nothing. */
num = 0; /* but, it's not error */
}
token.type = TokenType.RAW_BYTE;
token.setC(num);
}
}
private void fetchTokenFor_zero() {
if (syntax.opEscOctal3()) {
final int last = p;
int num = scanUnsignedOctalNumber(c == '0' ? 2 : 3);
if (num < 0) {
throw new ValueException(ERR_TOO_BIG_NUMBER);
}
if (p == last) {
/* can't read nothing. */
num = 0; /* but, it's not error */
}
token.type = TokenType.RAW_BYTE;
token.setC(num);
} else if (c != '0') {
inc();
}
}
private void fetchTokenFor_uHex() {
if (!left()) {
return;
}
final int last = p;
if (syntax.op2EscUHex4()) {
int num = scanUnsignedHexadecimalNumber(4);
if (num < 0) {
throw new ValueException(ERR_TOO_BIG_NUMBER);
}
if (p == last) {
/* can't read nothing. */
num = 0; /* but, it's not error */
}
token.type = TokenType.CODE_POINT;
token.setCode(num);
}
}
@Override
public void init(final Color color) {
super.init(color);
quoted = false;
}
/**
* Writes the current string to the graphics reference.
*
* @param g graphics reference
*/
private void write(final Graphics g) {
if (high) {
high = false;
} else {
color = isEnabled() ? syntax.getColor(text) : Color.gray;
}
final int ch = text.curr();
if (y > 0 && y < h) {
if (ch == TokenBuilder.MARK) {
color = GUIConstants.GREEN;
high = true;
}
// mark selected text
final int cp = text.pos();
if (text.selectStart()) {
int xx = x, cw = 0;
while (!text.inSelect() && text.more()) xx += charW(g, text.next());
while (text.inSelect() && text.more()) cw += charW(g, text.next());
g.setColor(GUIConstants.color(3));
g.fillRect(xx, y - fontH * 4 / 5, cw, fontH);
text.pos(cp);
}
// mark found text
int xx = x;
while (text.more() && text.searchStart()) {
int cw = 0;
while (!text.inSearch() && text.more()) xx += charW(g, text.next());
while (text.inSearch() && text.more()) cw += charW(g, text.next());
g.setColor(GUIConstants.color2A);
g.fillRect(xx, y - fontH * 4 / 5, cw, fontH);
xx += cw;
}
text.pos(cp);
if (text.erroneous()) drawError(g);
// don't write whitespaces
if (ch > ' ') {
g.setColor(color);
String n = text.nextString();
int ww = w - x;
if (x + wordW > ww) {
// shorten string if it cannot be completely shown (saves memory)
int c = 0;
for (final int nl = n.length(); c < nl && ww > 0; c++) {
ww -= charW(g, n.charAt(c));
}
n = n.substring(0, c);
}
g.drawString(n, x, y);
} else if (ch <= TokenBuilder.MARK) {
g.setFont(font);
}
// show cursor
if (cursor && text.edited()) {
xx = x;
while (text.more()) {
if (text.cursor() == text.pos()) {
drawCursor(g, xx);
break;
}
xx += charW(g, text.next());
}
text.pos(cp);
}
}
next();
}
protected final TokenType fetchToken() {
// mark(); // out
start:
while (true) {
if (!left()) {
token.type = TokenType.EOT;
return token.type;
}
token.type = TokenType.STRING;
token.backP = p;
fetch();
if (c == syntax.metaCharTable.esc
&& !syntax.op2IneffectiveEscape()) { // IS_MC_ESC_CODE(code, syn)
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_ESCAPE);
}
token.backP = p;
fetch();
token.setC(c);
token.escaped = true;
switch (c) {
case '*':
if (syntax.opEscAsteriskZeroInf()) {
fetchTokenFor_repeat(0, QuantifierNode.REPEAT_INFINITE);
}
break;
case '+':
if (syntax.opEscPlusOneInf()) {
fetchTokenFor_repeat(1, QuantifierNode.REPEAT_INFINITE);
}
break;
case '?':
if (syntax.opEscQMarkZeroOne()) {
fetchTokenFor_repeat(0, 1);
}
break;
case '{':
if (syntax.opEscBraceInterval()) {
fetchTokenFor_openBrace();
}
break;
case '|':
if (syntax.opEscVBarAlt()) {
token.type = TokenType.ALT;
}
break;
case '(':
if (syntax.opEscLParenSubexp()) {
token.type = TokenType.SUBEXP_OPEN;
}
break;
case ')':
if (syntax.opEscLParenSubexp()) {
token.type = TokenType.SUBEXP_CLOSE;
}
break;
case 'w':
if (syntax.opEscWWord()) {
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.W : CharacterType.WORD);
}
break;
case 'W':
if (syntax.opEscWWord()) {
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.W : CharacterType.WORD);
}
break;
case 'b':
if (syntax.opEscBWordBound()) {
fetchTokenFor_anchor(AnchorType.WORD_BOUND);
}
break;
case 'B':
if (syntax.opEscBWordBound()) {
fetchTokenFor_anchor(AnchorType.NOT_WORD_BOUND);
}
break;
case '<':
if (Config.USE_WORD_BEGIN_END && syntax.opEscLtGtWordBeginEnd()) {
fetchTokenFor_anchor(AnchorType.WORD_BEGIN);
}
break;
case '>':
if (Config.USE_WORD_BEGIN_END && syntax.opEscLtGtWordBeginEnd()) {
fetchTokenFor_anchor(AnchorType.WORD_END);
}
break;
case 's':
if (syntax.opEscSWhiteSpace()) {
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.S : CharacterType.SPACE);
}
break;
case 'S':
if (syntax.opEscSWhiteSpace()) {
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.S : CharacterType.SPACE);
}
break;
case 'd':
if (syntax.opEscDDigit()) {
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.D : CharacterType.DIGIT);
}
break;
case 'D':
if (syntax.opEscDDigit()) {
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.D : CharacterType.DIGIT);
}
break;
case 'h':
if (syntax.op2EscHXDigit()) {
fetchTokenInCCFor_charType(false, CharacterType.XDIGIT);
}
break;
case 'H':
if (syntax.op2EscHXDigit()) {
fetchTokenInCCFor_charType(true, CharacterType.XDIGIT);
}
break;
case 'A':
if (syntax.opEscAZBufAnchor()) {
fetchTokenFor_anchor(AnchorType.BEGIN_BUF);
}
break;
case 'Z':
if (syntax.opEscAZBufAnchor()) {
fetchTokenFor_anchor(AnchorType.SEMI_END_BUF);
}
break;
case 'z':
if (syntax.opEscAZBufAnchor()) {
fetchTokenFor_anchor(AnchorType.END_BUF);
}
break;
case 'G':
if (syntax.opEscCapitalGBeginAnchor()) {
fetchTokenFor_anchor(AnchorType.BEGIN_POSITION);
}
break;
case '`':
if (syntax.op2EscGnuBufAnchor()) {
fetchTokenFor_anchor(AnchorType.BEGIN_BUF);
}
break;
case '\'':
if (syntax.op2EscGnuBufAnchor()) {
fetchTokenFor_anchor(AnchorType.END_BUF);
}
break;
case 'x':
fetchTokenFor_xBrace();
break;
case 'u':
fetchTokenFor_uHex();
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
fetchTokenFor_digit();
break;
case '0':
fetchTokenFor_zero();
break;
default:
unfetch();
final int num = fetchEscapedValue();
/* set_raw: */
if (token.getC() != num) {
token.type = TokenType.CODE_POINT;
token.setCode(num);
} else {
/* string */
p = token.backP + 1;
}
break;
} // switch (c)
} else {
token.setC(c);
token.escaped = false;
if (Config.USE_VARIABLE_META_CHARS
&& (c != MetaChar.INEFFECTIVE_META_CHAR && syntax.opVariableMetaCharacters())) {
fetchTokenFor_metaChars();
break;
}
{
switch (c) {
case '.':
if (syntax.opDotAnyChar()) {
token.type = TokenType.ANYCHAR;
}
break;
case '*':
if (syntax.opAsteriskZeroInf()) {
fetchTokenFor_repeat(0, QuantifierNode.REPEAT_INFINITE);
}
break;
case '+':
if (syntax.opPlusOneInf()) {
fetchTokenFor_repeat(1, QuantifierNode.REPEAT_INFINITE);
}
break;
case '?':
if (syntax.opQMarkZeroOne()) {
fetchTokenFor_repeat(0, 1);
}
break;
case '{':
if (syntax.opBraceInterval()) {
fetchTokenFor_openBrace();
}
break;
case '|':
if (syntax.opVBarAlt()) {
token.type = TokenType.ALT;
}
break;
case '(':
if (peekIs('?') && syntax.op2QMarkGroupEffect()) {
inc();
if (peekIs('#')) {
fetch();
while (true) {
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_IN_GROUP);
}
fetch();
if (c == syntax.metaCharTable.esc) {
if (left()) {
fetch();
}
} else {
if (c == ')') {
break;
}
}
}
continue start; // goto start
}
unfetch();
}
if (syntax.opLParenSubexp()) {
token.type = TokenType.SUBEXP_OPEN;
}
break;
case ')':
if (syntax.opLParenSubexp()) {
token.type = TokenType.SUBEXP_CLOSE;
}
break;
case '^':
if (syntax.opLineAnchor()) {
fetchTokenFor_anchor(
isSingleline(env.option) ? AnchorType.BEGIN_BUF : AnchorType.BEGIN_LINE);
}
break;
case '$':
if (syntax.opLineAnchor()) {
fetchTokenFor_anchor(
isSingleline(env.option) ? AnchorType.END_BUF : AnchorType.END_LINE);
}
break;
case '[':
if (syntax.opBracketCC()) {
token.type = TokenType.CC_CC_OPEN;
}
break;
case ']':
// if (*src > env->pattern) /* /].../ is allowed. */
// CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]");
break;
case '#':
if (Option.isExtend(env.option)) {
while (left()) {
fetch();
if (EncodingHelper.isNewLine(c)) {
break;
}
}
continue start; // goto start
}
break;
case ' ':
case '\t':
case '\n':
case '\r':
case '\f':
if (Option.isExtend(env.option)) {
continue start; // goto start
}
break;
default: // string
break;
} // switch
}
}
break;
} // while
return token.type;
}
public Syntax getSyntax() {
return Syntax.commandSyntax(new int[] {});
}
private void fetchTokenInCCFor_and() {
if (syntax.op2CClassSetOp() && left() && peekIs('&')) {
inc();
token.type = TokenType.CC_AND;
}
}
public void updateStateInfo(Syntax syntax) {
if (stateInfo == null) {
stateInfo = syntax.createStateInfo();
}
syntax.storeState(stateInfo);
}
protected final TokenType fetchTokenInCC() {
if (!left()) {
token.type = TokenType.EOT;
return token.type;
}
fetch();
token.type = TokenType.CHAR;
token.setC(c);
token.escaped = false;
if (c == ']') {
token.type = TokenType.CC_CLOSE;
} else if (c == '-') {
token.type = TokenType.CC_RANGE;
} else if (c == syntax.metaCharTable.esc) {
if (!syntax.backSlashEscapeInCC()) {
return token.type;
}
if (!left()) {
throw new SyntaxException(ERR_END_PATTERN_AT_ESCAPE);
}
fetch();
token.escaped = true;
token.setC(c);
switch (c) {
case 'w':
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.W : CharacterType.WORD);
break;
case 'W':
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.W : CharacterType.WORD);
break;
case 'd':
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.D : CharacterType.DIGIT);
break;
case 'D':
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.D : CharacterType.DIGIT);
break;
case 's':
fetchTokenInCCFor_charType(
false, Config.NON_UNICODE_SDW ? CharacterType.S : CharacterType.SPACE);
break;
case 'S':
fetchTokenInCCFor_charType(
true, Config.NON_UNICODE_SDW ? CharacterType.S : CharacterType.SPACE);
break;
case 'h':
if (syntax.op2EscHXDigit()) {
fetchTokenInCCFor_charType(false, CharacterType.XDIGIT);
}
break;
case 'H':
if (syntax.op2EscHXDigit()) {
fetchTokenInCCFor_charType(true, CharacterType.XDIGIT);
}
break;
case 'x':
fetchTokenInCCFor_x();
break;
case 'u':
fetchTokenInCCFor_u();
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
fetchTokenInCCFor_digit();
break;
default:
unfetch();
final int num = fetchEscapedValue();
if (token.getC() != num) {
token.setCode(num);
token.type = TokenType.CODE_POINT;
}
break;
} // switch
} else if (c == '&') {
fetchTokenInCCFor_and();
}
return token.type;
}
/** @return 0: normal {n,m}, 2: fixed {n} !introduce returnCode here */
private int fetchRangeQuantifier() {
mark();
final boolean synAllow = syntax.allowInvalidInterval();
if (!left()) {
if (synAllow) {
return 1; /* "....{" : OK! */
}
throw new SyntaxException(ERR_END_PATTERN_AT_LEFT_BRACE);
}
if (!synAllow) {
c = peek();
if (c == ')' || c == '(' || c == '|') {
throw new SyntaxException(ERR_END_PATTERN_AT_LEFT_BRACE);
}
}
int low = scanUnsignedNumber();
if (low < 0) {
throw new SyntaxException(ErrorMessages.ERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE);
}
if (low > Config.MAX_REPEAT_NUM) {
throw new SyntaxException(ErrorMessages.ERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE);
}
boolean nonLow = false;
if (p == _p) {
/* can't read low */
if (syntax.allowIntervalLowAbbrev()) {
low = 0;
nonLow = true;
} else {
return invalidRangeQuantifier(synAllow);
}
}
if (!left()) {
return invalidRangeQuantifier(synAllow);
}
fetch();
int up;
int ret = 0;
if (c == ',') {
final int prev = p; // ??? last
up = scanUnsignedNumber();
if (up < 0) {
throw new ValueException(ERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE);
}
if (up > Config.MAX_REPEAT_NUM) {
throw new ValueException(ERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE);
}
if (p == prev) {
if (nonLow) {
return invalidRangeQuantifier(synAllow);
}
up = QuantifierNode.REPEAT_INFINITE; /* {n,} : {n,infinite} */
}
} else {
if (nonLow) {
return invalidRangeQuantifier(synAllow);
}
unfetch();
up = low; /* {n} : exact n times */
ret = 2; /* fixed */
}
if (!left()) {
return invalidRangeQuantifier(synAllow);
}
fetch();
if (syntax.opEscBraceInterval()) {
if (c != syntax.metaCharTable.esc) {
return invalidRangeQuantifier(synAllow);
}
fetch();
}
if (c != '}') {
return invalidRangeQuantifier(synAllow);
}
if (!isRepeatInfinite(up) && low > up) {
throw new ValueException(ERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE);
}
token.type = TokenType.INTERVAL;
token.setRepeatLower(low);
token.setRepeatUpper(up);
return ret; /* 0: normal {n,m}, 2: fixed {n} */
}
public String details() {
return "CmdsInAList(" + "cmds=" + "[" + Syntax.sepDetails(this.cmds, ",") + "]" + ")";
}
public String details() {
return "PostExpArgs(" + "args=" + "[" + Syntax.sepDetails(this.args, ",") + "]" + ")";
}
public Syntax getSyntax() {
return Syntax.reporterSyntax(new int[] {Syntax.NumberType()}, Syntax.ListType());
}
