/[svn]/linuxsampler/trunk/src/network/lscp.y

Diff of /linuxsampler/trunk/src/network/lscp.y

Parent Directory | Revision Log | View Patch Patch

-revision 2523 by schoenebeck,
Sun Feb 23 19:10:36 2014 UTC
+revision 2525 by schoenebeck,
Mon Feb 24 17:52:51 2014 UTC
 Line 180 
 void yyerror(void* x, const char* s) {
  %parse-param {void* yyparse_param}
  // After entering the yyparse() function, store references to the parser's
- // state stack, so that we can create more helpful syntax error messages than
+ // symbol stack, so that we can create more helpful syntax error messages than
  // Bison (2.x) could do.
  %initial-action {
      yyparse_param_t* p = (yyparse_param_t*) yyparse_param;
 Line 1348 
 inline static BisonSymbolInfo _symbolInf
  #else // Bison 2.x or older ...
+ //TODO: The Bison 2.x code below can probably soon just be deleted. Most Bisonx 2.x versions should be able to compile successfully with the Bison 3.x code above as well (just requires the existence of table yystos[] in the auto generated lscpparser.cpp).
  /**
   * Returns true if the given grammar @a rule is a terminal symbol (in *our*
   * terms).
-Line 1455 
 static bool yyValid(std::vector<YYTYPE_I
+Line 1457 
 static bool yyValid(std::vector<YYTYPE_I
   * precise parse position & state represented by @a stack, according to Bison's
   * LALR(1) parser algorithm.
   *
-  * This function is given a Bison parser state stack, reflecting the parser's
+  * This function is given a Bison parser symbol stack, reflecting the parser's
   * entire state at a certain point, i.e. when a syntax error occured. This
   * function will then walk ahead the potential parse tree starting from the
-  * current head of the given state stack. This function will call itself
+  * current head of the given symbol stack. This function will call itself
   * recursively to scan the individual parse tree branches. As soon as it hits
   * on the next non-terminal grammar symbol in one parse tree branch, it adds the
   * found non-terminal symbol to @a expectedSymbols and aborts scanning the
   * respective tree branch further. If any local parser state is reached a second
   * time, the respective parse tree is aborted to avoid any endless recursion.
   *
-  * @param stack - current Bison (yacc) state stack to be examined
+  * @param stack - current Bison (yacc) symbol stack to be examined
   * @param expectedSymbols - will be filled with next expected grammar symbols
   * @param nextExpectedChars - just for internal purpose, due to the recursive
   *                            implementation of this function, do supply an
-Line 1480 
 static void walkAndFillExpectedSymbols(
+Line 1482 
 static void walkAndFillExpectedSymbols(
  #if DEBUG_BISON_SYNTAX_ERROR_WALKER
      printf("\n");
      for (int i = 0; i < depth; ++i) printf("\t");
-     printf("State stack:");
+     printf("Symbol stack:");
      for (int i = 0; i < stack.size(); ++i) {
          printf(" %d", stack[i]);
      }
-Line 1512 
 static void walkAndFillExpectedSymbols(
+Line 1514 
 static void walkAndFillExpectedSymbols(
          for (int i = 0; i < depth; ++i) printf("\t");
          printf("(default reduction)\n");
  #endif
+         #if HAVE_BISON_MAJ >= 3
          if (!nextExpectedChars.empty() || !_isRuleTerminalSymbol(n, stack)) {
+         #else
+         if (!nextExpectedChars.empty() || !_isRuleTerminalSymbol(n)) {
+         #endif
              // Return the new resolved expected symbol (left-hand symbol of grammar
              // rule), then we're done in this state. (If the same symbol can be
              // matched on different ways, then it is non-terminal symbol.)
-Line 1619 
 static void walkAndFillExpectedSymbols(
+Line 1625 
 static void walkAndFillExpectedSymbols(
              continue; // duplicate state, ignore it to avoid endless recursions
          }
-         // "shift" / push the new state on the state stack and call this
+         // "shift" / push the new state on the symbol stack and call this
          // function recursively, and restore the stack after the recurse return
          stackSize = stack.size();
          nextExpectedCharsLen = nextExpectedChars.size();
-Line 1682 
 static bool yyPushParse(std::vector<YYTY
+Line 1688 
 static bool yyPushParse(std::vector<YYTY
  #if DEBUG_PUSH_PARSE
      //printf("\n");
      //for (int i = 0; i < depth; ++i) printf("\t");
-     printf("State stack:");
+     printf("Symbol stack:");
      for (int i = 0; i < stack.size(); ++i) {
          printf(" %d", stack[i]);
      }
-Line 1759 
 static bool yyValid(std::vector<YYTYPE_I
+Line 1765 
 static bool yyValid(std::vector<YYTYPE_I
   * Returns the amount of correct characters of given @a line from the left,
   * according to the LSCP grammar.
   *
-  * @param stack - a Bison symbol state stack to work with
+  * @param stack - a Bison symbol stack to work with
   * @param line  - the input line to check
   * @param bAutoCorrect - if true: try to correct obvious, trivial syntax errors
   */
-Line 1767 
 static int yyValidCharacters(std::vector
+Line 1773 
 static int yyValidCharacters(std::vector
      int i;
      for (i = 0; i < line.size(); ++i) {
          // since we might check the same parser state twice against the current
-         // char here below, and since the state stack might be altered
+         // char here below, and since the symbol stack might be altered
          // (i.e. shifted or reduced) on syntax errors, we have to backup the
-         // current state stack and restore it on syntax errors below
+         // current symbol stack and restore it on syntax errors below
          std::vector<YYTYPE_INT16> stackCopy = stack;
          if (yyValid(stackCopy, line[i])) {
              stack = stackCopy;
-Line 1807 
 static std::set<String> yyExpectedSymbol
+Line 1813 
 static std::set<String> yyExpectedSymbol
      YYTYPE_INT16* ss = (*param->ppStackBottom);
      YYTYPE_INT16* sp = (*param->ppStackTop);
      int iStackSize   = sp - ss + 1;
-     // copy and wrap parser's state stack into a convenient STL container
+     // copy and wrap parser's symbol stack into a convenient STL container
      std::vector<YYTYPE_INT16> stack;
      for (int i = 0; i < iStackSize; ++i) {
          stack.push_back(ss[i]);
-Line 1826 
 static std::set<String> yyExpectedSymbol
+Line 1832 
 static std::set<String> yyExpectedSymbol
  #define DEBUG_YY_AUTO_COMPLETE 0
  /**
-  * A set of parser state stacks. This type is used in yyAutoComplete() to keep
+  * A set of parser symbol stacks. This type is used in yyAutoComplete() to keep
-  * track of all previous parser states, for detecting a parser state stack that
+  * track of all previous parser states, for detecting a parser symbol stack that
   * has already been before. Because if yyAutoComplete() reaches the exactly same
-  * parser state stack again, it means there is an endless recursion in that
+  * parser symbol stack again, it means there is an endless recursion in that
   * part of the grammar tree branch and shall not be evaluated any further,
   * because it would end up in an endless loop otherwise.
   *
-Line 1841 
 typedef std::set< std::vector<YYTYPE_INT
+Line 1847 
 typedef std::set< std::vector<YYTYPE_INT
  /**
   * Generates and returns an auto completion string for the current parser
-  * state given by @a stack.
+  * state given by @a stack. That means, this function will return the longest
+  * sequence of characters that is uniqueley expected to be sent next by the LSCP
+  * client. Or in other words, if the LSCP client would send any other
+  * character(s) than returned here, it would result in a syntax error.
+  *
+  * This function takes a Bison symbol @a stack as argument, reflecting the
+  * current Bison parser state, and evaluates the individual grammar tree
+  * branches starting from that particular position. It walks along the grammar
+  * tree as long as there is only one possible tree branch and assembles a string
+  * of input characters that would lead to that walk through the grammar tree. As
+  * soon as a position in the grammar tree is reached where there are multiple
+  * possible tree branches, this algorithm will stop, since the user could have
+  * multiple possible valid characters he could type at that point, thus auto
+  * completion would no longer be unique at that point.
   *
   * Regarding @a history argument: read the description on YYStackHistory for the
   * purpose behind this argument.
   *
-  * @param stack - current Bison (yacc) state stack to create auto completion for
+  * @param stack - current Bison (yacc) symbol stack to create auto completion for
-  * @param history - only for internal purpose, keeps a history of all previous parser state stacks
+  * @param history - only for internal purpose, keeps a history of all previous
+  *                  parser symbol stacks (just for avoiding endless recursion in
+  *                  this auto completion algorithm)
   * @param depth - just for internal debugging purposes
   * @returns auto completion for current, given parser state
   */
-Line 1969 
 namespace LinuxSampler {
+Line 1990 
 namespace LinuxSampler {
  #define DEBUG_SHELL_INTERACTION 0
  /**
-  * If LSP shell mode is enabled for the respective LSCP client connection, then
+  * If LSCP shell mode is enabled for the respective LSCP client connection, then
   * this function is called on every new byte received from that client. It will
-  * check the current total input line and reply to the LSCP shell for providing
+  * check the current total input line and reply to the LSCP shell with a
-  * colored syntax highlighting and potential auto completion in the shell.
+  * specially crafted string, which allows the shell to provide colored syntax
+  * highlighting and potential auto completion in the shell.
   *
   * It also performs auto correction of obvious & trivial syntax mistakes if
   * requested.
   *
   * The return value of this function will be sent to the client. It contains one
-  * line specially formatted for the LSCP shell, which can easily be processed by
+  * line specially formatted for the LSCP shell application, which can easily be
-  * the client/shell for gettings its necessary informations like which part of
+  * processed by the client/shell for extracting its necessary informations like
-  * the current command line is syntactically correct, which part is incorrect,
+  * which part of the current command line is syntactically correct, which part
-  * what could be auto completed right now, etc.
+  * is incorrect, what could be auto completed right now, etc. So all the heavy
+  * grammar evaluation tasks are peformed by the LSCP server for the LSCP shell
+  * application (which is desgined as a thin client), so the LSCP shell
+  * application will only have to show the results of the LSCP server's
+  * evaluation to the user on the screen.
   *
   * @returns LSCP shell response line to be returned to the client
   */
-Line 2011 
 String lscpParserProcessShellInteraction
+Line 2037 
 String lscpParserProcessShellInteraction
      // get a clean parser stack to the last valid parse position
      // (due to the appended '\n' character above, and on syntax errors, the
-     // state stack might be in undesired, i.e. reduced state)
+     // symbol stack might be in undesired, i.e. reduced state)
      stack.clear();
      stack.push_back(0); // every Bison symbol stack starts with state zero
      l = line.substr(0, n);

 Legend:



Removed from v.2523
 


changed lines


 
Added in v.2525
 Legend:



Removed from v.2523
 


changed lines


 
Added in v.2525
-Removed from v.2523
+Added in v.2525

	ViewVC Help
Powered by ViewVC