private void parseKeywordAndArgs() {

    if (!keyword_parsed) {
      keyword_parsed = true;
      ParsedString keywordOrSetting = line.arguments.get(argOff);
      keywordSequence_isSetting = keywordOrSetting.getValue().startsWith("[");
      if (keywordSequence_isSetting) {
        keywordSequence_keywordCallState = KeywordCallState.UNDETERMINED_NOT_FOR_NOINDENT; // TODO
        // possibly
        // should
        // be
        // KEYWORD_NOT_FOR_NOINDENT
        keywordSequence_settingType = keywordSequenceSettingTypes.get(keywordOrSetting.getValue());
        if (keywordSequence_settingType == null) {
          keywordSequence_settingType = SettingType.UNKNOWN;
        }
        keywordOrSetting.setType(ArgumentType.SETTING_KEY);
        prepareNextToken();
      } else {
        keywordSequence_keywordCallState = KeywordCallState.UNDETERMINED;
        parseKeywordCall(lastRealType.isTestCaseLine());
      }
    } else {
      if (keywordSequence_isSetting) {
        parseKeywordSequenceSetting();
      } else {
        parseKeywordCall(lastRealType.isTestCaseLine());
      }
    }
  }
 private void setUpKeywordArgPos(ParsedString keyword) {
   keywordSequence_keywordArgPos = KEYWORD_ARG_POS_NONE;
   if (keywordsTakingKeywords.containsKey(keyword.getValue())) {
     int keywordArgumentPosition = keywordsTakingKeywords.get(keyword.getValue());
     keywordSequence_keywordArgPos = keywordArgumentPosition;
     if (keywordArgumentPosition != KEYWORD_ARG_POS_ALL) {
       keywordSequence_currentArgPos = 1;
     }
   }
 }
 void prepareNextLine() {
   assert argOff >= 0;
   assert argOff <= argLen;
   // if previous line ended with comment, add it to queue now
   if (lineEndsWithComment) {
     ParsedString comment = line.arguments.get(argLen);
     if (comment.getValue().startsWith("#")) {
       comment.setType(ArgumentType.COMMENT);
     }
   }
   // next line
   line = getNextNonemptyLine();
   if (line != null) {
     argLen = line.arguments.size();
     lineEndsWithComment = line.arguments.get(argLen - 1).getValue().startsWith("#");
     if (lineEndsWithComment) {
       --argLen; // exclude now, deal with it later (see top of method)
     }
   } else {
     // for (RobotLine line : lines) {
     // System.out.println(line);
     // }
     lines = null;
     lineIterator = null;
     argLen = 0;
     lineEndsWithComment = false;
   }
   argOff = 0;
 }
 @Override
 protected void addProposal(ParsedString proposal, FileWithType proposalLocation) {
   String proposalString = proposal.getValue().toLowerCase();
   boolean proposalExisted = addedProposals.contains(proposalString);
   super.addProposal(proposal, proposalLocation);
   if (proposalExisted) {
     for (RobotCompletionProposal robotCompletionProposal : proposals) {
       setPrefixRequiredIfNeeded(proposalString, robotCompletionProposal);
     }
   }
 }
 private void parseSettingTableLineToken() {
   switch (argOff) {
     case 0:
       {
         ParsedString setting = line.arguments.get(0);
         setting.setType(ArgumentType.SETTING_KEY);
         setting_type = settingTypes.get(setting.getValue());
         if (setting_type == null) {
           setting_type = SettingType.UNKNOWN;
         }
         setting_gotFirstArg = false;
         // TODO possibly should be KEYWORD_NOT_FOR_NOINDENT:
         keywordSequence_keywordCallState = KeywordCallState.UNDETERMINED_NOT_FOR_NOINDENT;
         prepareNextToken();
         return;
       }
     default:
       {
         parseSettingArgs();
         return;
       }
   }
 }
 private KeywordCallState scanLine(
     KeywordCallState initialKeywordCallState, RobotLine scanLine, int scanOff) {
   assert initialKeywordCallState.isUndetermined();
   for (; scanOff < scanLine.arguments.size(); ++scanOff) {
     ParsedString parsedString = scanLine.arguments.get(scanOff);
     if (parsedString.isEmpty()) {
       if (initialKeywordCallState == KeywordCallState.UNDETERMINED) {
         // no variables yet
         continue;
       } else {
         // no equal sign found before first non-variable parameter
         return initialKeywordCallState == KeywordCallState.UNDETERMINED_NOT_FOR_NOINDENT
             ? KeywordCallState.KEYWORD_NOT_FOR_NOINDENT
             : KeywordCallState.KEYWORD;
       }
     }
     String arg = parsedString.getValue();
     switch (arg.charAt(0)) {
       case '$':
       case '@':
         // TODO ensure it's a proper lvalue
         initialKeywordCallState = KeywordCallState.UNDETERMINED_GOTVARIABLE;
         break;
       default:
         // non-variable and no prior lvalue indication, so..
         return initialKeywordCallState == KeywordCallState.UNDETERMINED_NOT_FOR_NOINDENT
             ? KeywordCallState.KEYWORD_NOT_FOR_NOINDENT
             : KeywordCallState.KEYWORD;
     }
     if (arg.endsWith("=")) {
       return initialKeywordCallState == KeywordCallState.UNDETERMINED_NOT_FOR_NOINDENT
           ? KeywordCallState.LVALUE_NOINDENT
           : KeywordCallState.LVALUE;
     }
   }
   return initialKeywordCallState;
 }
 @Override
 public VisitorInterest visitMatch(ParsedString proposal, FileWithType proposalLocation) {
   if (userInput == null) {
     addProposal(proposal, proposalLocation);
   } else {
     String userInputString = userInput.getValue().toLowerCase();
     String proposalString = proposal.getValue().toLowerCase();
     if (proposalString.contains(userInputString)
         || matchesWithoutPrefix(userInputString, proposalString, proposalLocation)) {
       addProposal(proposal, proposalLocation);
     }
     // if (KeywordMatchResult.DIFFERENT == match(proposalString, lookFor(userInputString))) {
     // if (!prefixesMatch(userInputString, proposalLocation)) {
     // return VisitorInterest.CONTINUE;
     // }
     // if (KeywordMatchResult.DIFFERENT == match(proposalString,
     // lookFor(valueWithoutPrefix(userInputString))))
     // {
     // return VisitorInterest.CONTINUE;
     // }
     // }
   }
   return VisitorInterest.CONTINUE;
 }
 /**
  * Before this is called the first time, keywordSequence_keywordCallState must be initialized to
  * either UNDETERMINED, UNDETERMINED_NOINDENT, KEYWORD_NOINDENT, KEYWORD_NOT_FOR_NOINDENT
  *
  * @param templatesEnabled whether the template flags {@link #globalTemplateAtLine} and {@link
  *     #localTemplateAtLine} affect keyword calls during this invocation
  */
 private void parseKeywordCall(boolean templatesEnabled) {
   if (keywordSequence_keywordCallState.isUndetermined()) {
     keywordSequence_keywordCallState =
         determineInitialKeywordCallState(keywordSequence_keywordCallState);
   }
   switch (keywordSequence_keywordCallState) {
     case LVALUE_NOINDENT:
     case LVALUE:
       {
         ParsedString variable = line.arguments.get(argOff);
         if (!variable.isEmpty()
             || keywordSequence_keywordCallState == KeywordCallState.LVALUE_NOINDENT) {
           variable.setType(ArgumentType.KEYWORD_LVALUE);
           if (variable.getValue().endsWith("=")) {
             keywordSequence_keywordCallState = KeywordCallState.KEYWORD_NOT_FOR_NOINDENT;
           }
         }
         prepareNextToken();
         return;
       }
     case KEYWORD_NOT_FOR_NOINDENT:
     case KEYWORD:
       {
         ParsedString keyword = line.arguments.get(argOff);
         if (!keyword.isEmpty()
             || keywordSequence_keywordCallState == KeywordCallState.KEYWORD_NOT_FOR_NOINDENT) {
           if (keyword.getValue().equals(":FOR")
               && keywordSequence_keywordCallState != KeywordCallState.KEYWORD_NOT_FOR_NOINDENT) {
             keyword.setType(ArgumentType.FOR_PART);
             keywordSequence_keywordCallState = KeywordCallState.FOR_VARS;
           } else {
             if (templatesEnabled && isTemplateActive()) {
               keyword.setType(ArgumentType.KEYWORD_ARG);
               // TODO support "Run Keyword If" etc as template keyword
               keywordSequence_keywordArgPos = KEYWORD_ARG_POS_NONE;
             } else if (NONE_STR.equals(keyword.getValue())) {
               // TODO verify what is this branch about
               keyword.setType(ArgumentType.SETTING_VAL);
               keywordSequence_keywordArgPos = KEYWORD_ARG_POS_NONE;
             } else {
               keyword.setType(ArgumentType.KEYWORD_CALL);
               setUpKeywordArgPos(keyword);
             }
             keywordSequence_keywordCallState = KeywordCallState.KEYWORD_ARGS;
           }
         }
         prepareNextToken();
         return;
       }
     case FOR_VARS:
       {
         ParsedString arg = line.arguments.get(argOff);
         String argVal = arg.getValue();
         if (argVal.equals("IN") || argVal.equals("IN RANGE")) {
           arg.setType(ArgumentType.FOR_PART);
           keywordSequence_keywordCallState = KeywordCallState.FOR_ARGS;
           prepareNextToken();
           return;
         }
         arg.setType(ArgumentType.KEYWORD_LVALUE);
         prepareNextToken();
         return;
       }
     case FOR_ARGS:
       {
         setArgTypesToEol(ArgumentType.KEYWORD_ARG);
         prepareNextLine();
         return;
       }
     case KEYWORD_ARGS:
       {
         ParsedString arg = line.arguments.get(argOff);
         boolean isKeyword;
         switch (keywordSequence_keywordArgPos) {
           case KEYWORD_ARG_POS_NONE:
             isKeyword = false;
             break;
           case KEYWORD_ARG_POS_ALL:
             isKeyword = true;
             break;
           default:
             isKeyword = keywordSequence_currentArgPos++ == keywordSequence_keywordArgPos;
             if (isKeyword) {
               setUpKeywordArgPos(arg);
             }
             break;
         }
         if (isKeyword) {
           arg.setType(ArgumentType.KEYWORD_CALL_DYNAMIC);
         } else {
           arg.setType(ArgumentType.KEYWORD_ARG);
         }
         prepareNextToken();
         return;
       }
     default:
       throw new RuntimeException();
   }
 }
 private void parseSettingArgs() {
   switch (setting_type) {
     case UNKNOWN:
       {
         prepareNextLine();
         return;
       }
     case STRING:
       {
         setArgTypesToEol(ArgumentType.SETTING_VAL);
         prepareNextLine();
         return;
       }
     case FILE:
       {
         ParsedString file = line.arguments.get(argOff);
         file.setType(ArgumentType.SETTING_FILE);
         prepareNextLine();
         return;
       }
     case FILE_ARGS:
       {
         if (!setting_gotFirstArg) {
           ParsedString file = line.arguments.get(argOff);
           file.setType(ArgumentType.SETTING_FILE);
           prepareNextToken();
           setting_gotFirstArg = true;
           setting_withNameState = WithNameState.NONE;
           return;
         } else {
           switch (setting_withNameState) {
             case NONE:
               ParsedString arg = line.arguments.get(argOff);
               if (arg.getValue().equals("WITH NAME")) {
                 setting_withNameState = WithNameState.GOT_KEY;
                 arg.setType(ArgumentType.SETTING_FILE_WITH_NAME_KEY);
               } else {
                 arg.setType(ArgumentType.SETTING_FILE_ARG);
               }
               prepareNextToken();
               return;
             case GOT_KEY:
               ParsedString name = line.arguments.get(argOff);
               name.setType(ArgumentType.SETTING_FILE_WITH_NAME_VALUE);
               setting_withNameState = WithNameState.GOT_VALUE;
               prepareNextLine();
               return;
             case GOT_VALUE:
               prepareNextLine();
               return;
           }
         }
         throw new RuntimeException();
       }
     case KEYWORD_ARGS:
       {
         parseKeywordCall(false);
         return;
       }
   }
   throw new RuntimeException();
 }
 static int determineContinuationLineArgOff(RobotLine theLine) {
   List<ParsedString> arguments = theLine.arguments;
   ParsedString parsedString = arguments.get(0);
   String value = parsedString.getValue();
   return value.equals(PreParser.CONTINUATION_STR) ? 1 : 2;
 }
 @Override
 public String toString() {
   return parsedString.getValue();
 }