/** * Skips the next token if it matches the given input, and appends it to the output formatting * stream with the given syntax value. */ private boolean skipNext(String token, int syntax) { if (lexer.hasNext() && lexer.peekNext().equals(token)) { append(lexer.getNext(), syntax); return true; } return false; }
/** * Formats a loop command. * * @return */ private boolean formatLoopCommand() { Loop l = NXTalk.getLoop(lexer.peekNext()); if (l == null) return false; append(lexer.getNext(), Syntax.Loop); formatExpression(); return true; }
/** Formats one or more motor directives that are appended to the end of motor commands. */ private void formatMotorDirectives() { if (lexer.atCommandEnd()) return; while (NXTalk.getMotorDirective(lexer.peekNext()) != null) { append(lexer.getNext(), Syntax.MotorDirective); skipNext("and"); } }
/** Formats a symbol declaration. */ private void formatSymbolDeclaration() { if (lexer.hasNext() && lexer.peekNext().matches(NXTalk.validSymbolName)) { recognizedSymbols.add(lexer.peekNext()); append(Syntax.Symbol); } else { append(Syntax.InvalidSymbol); } }
/** Returns true if this instance can format a scalar terminal. */ private boolean canFormatScalarTerminal() { try { Integer.parseInt(lexer.peekNext()); return true; } catch (NumberFormatException n) { try { Double.parseDouble(lexer.peekNext()); return true; } catch (NumberFormatException n2) { return false; } } }
/** Formats an expression. */ private void formatExpression() { if (!lexer.hasNext()) return; formatFactor(); if (canFormatOperator()) { formatOperator(); formatExpression(); } }
/** Formats a string. */ private void formatStringTerminal() { skipNext(NXTalk.stringDelimiter, Syntax.String); if (lexer.peekNext().indexOf(NXTalk.caretIndicator) != -1) { } else { append(Syntax.String); } skipNext(NXTalk.stringDelimiter, Syntax.String); }
/** Formats the text input. */ public NXTalkFormatterOutput formatInput(String input, int caretPosition) { // Reset the output data structures output.reset(); // Set the output data structures and lex the input text output.set(input); lexer.lex(input); caret = caretPosition; // Go through each token in the input stream, and pass it to a // coloring function if it matches certain key phrases. while (lexer.hasNext()) { // Passes commands to a command formatter if (formatCommand()) { } // Passes loop commands to a loop formatter else if (formatLoopCommand()) { } else append(lexer.getNext(), Syntax.Null); } output.setCaretPosition(caret); return output; }
private void formatTerminal() { if (canFormatScalarTerminal()) { formatScalarTerminal(); formatUnit(); } else if (NXTalk.getSensor(lexer.peekNext()) != null) formatSensorTerminal(); else if (lexer.peekNext().equals(NXTalk.stringDelimiter)) formatStringTerminal(); else if (lexer.peekNext().equals("yes") || lexer.peekNext().equals("no")) append(lexer.getNext(), Syntax.Boolean); else if (recognizedSymbols.contains(lexer.peekNext())) { append(lexer.getNext(), Syntax.Symbol); formatUnit(); } }
/** Formats one or more motors. */ private void formatMotors() { while (lexer.hasNext() && NXTalk.getMotor(lexer.peekNext()) != null) append(lexer.getNext(), Syntax.Motor); }
/** Formats a sensor. */ private void formatSensorTerminal() { append(Syntax.Sensor); if (NXTalk.getSensorAction(lexer.peekNext()) != null) append(Syntax.SensorAction); }
/** Appends the given String text with the given syntax type. */ private void append(String text, int syntaxType) { if (text == null || text.length() == 0) return; output.addFormatting(lexer.getRepresentation(text), "" + syntaxType); }
/** * Appends the next token in the lexer output to the NXTalkFormatterOutput instance, inferring the * syntax type of the token. */ private void append() { append(lexer.peekNext(), lexer.getDictionary().contains(lexer.getNext())); }
/** Appends the given text to the formatted output text. */ private void append(String text) { output.addFormatting(lexer.getRepresentation(text), "" + lexer.getDictionary().contains(text)); }
/** * Appends the next token in the lexer output to the NXTalkFormatterOutput instance, with the * given syntax type. */ private void append(int syntaxType) { append(lexer.getNext(), syntaxType); }
/** Formats a motor direction statement. */ private void formatDirection() { if (NXTalk.getDirection(lexer.peekNext()) != null) append(lexer.getNext(), Syntax.Direction); }
/** Formats a new line statement. */ private void formatNewLine() { if (lexer.atCommandEnd()) append(lexer.getNext(), Syntax.Null); }
/** Formats an operator. */ private void formatOperator() { append(lexer.getNext(), Syntax.Operator); if (lexer.atCommandEnd()) append(); }
/** Prints a debug message. */ private void debugPrint(String message) { System.out.println(message + "[" + lexer.peekNext() + "]"); }
/** Returns true if the next token is an operator. */ private boolean canFormatOperator() { return NXTalk.getOperator(lexer.peekNext()) != null; }
/** * Formats subsets of the token stream that begin with an element of the Command enum of NXTalk. */ private boolean formatCommand() { // Get the command, then append it to the output stream Command command = NXTalk.getCommand(lexer.peekNext()); if (command == null) return false; append(Syntax.Command); // Pass evaluation of formatting to other formatting methods switch (command) { case Start: formatMotors(); // start <motor>+ formatDirection(); // start <motor>+ <direction>? if (skipNext("and")) { // start <motor>+ <direction>? and? <inner motor command> formatMotors(); // <motor>+ formatDirection(); // <direction> } if (skipNext("for")) // start <motor>+ <direction>? for <expr> formatExpression(); formatMotorDirectives(); // ... <motor directive>* break; case Stop: formatMotors(); // stop <motor>+ break; case Rotate: formatMotors(); // rotate <motor>+ if (skipNext("to", Syntax.Command)) { // rotate <motor>+ to <expr> formatExpression(); } else { formatDirection(); // rotate <motor>+ <direction> formatMotorDirectives(); // <motor directives>* } case Set: formatSymbolDeclaration(); skipNext("to", Syntax.Command); formatExpression(); break; case Wait: skipNext("until", Syntax.Command); formatExpression(); break; case Coast: formatMotors(); skipNext("until", Syntax.Keyword); skipNext("stop", Syntax.Keyword); break; case If: formatExpression(); // The branching condition indentLevel++; break; case ElseIf: formatExpression(); // The branching condition break; case Print: formatExpression(); // The expression being printed break; case EndCommand: /*if (indent) { Command c = NXTalk.getCommand(lexer.peekNext()); if (c == Command.EndIf || c == Command.Else || c == Command.ElseIf || c == Command.EndRotate || c == Command.EndGroup || c == Command.EndRepeat) break; for (int i = 0 ; i < indentLevel ; i++) append("\t", Syntax.Null); if (caret > output.getFormattedLength()) caret++; }*/ break; } return true; }
/** Formats a unit. */ private void formatUnit() { if (NXTalk.getUnit(lexer.peekNext()) != null) append(Syntax.Unit); }