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()); }