Source: lib/util/text_parser.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.TextParser');
  20. goog.require('goog.asserts');
  24. /**
  25.  * Reads elements from strings.
  26.  *
  27.  * @param {string} data
  28.  * @constructor
  29.  * @struct
  30.  */
  31. shaka.util.TextParser = function(data) {
  32.   /**
  33.    * @const
  34.    * @private {string}
  35.    */
  36.   this.data_ = data;
  38.   /** @private {number} */
  39.   this.position_ = 0;
  40. };
  43. /** @return {boolean} Whether it is at the end of the string. */
  44. shaka.util.TextParser.prototype.atEnd = function() {
  45.   return this.position_ == this.data_.length;
  46. };
  49. /**
  50.  * Reads a line from the parser.  This will read but not return the newline.
  51.  * Returns null at the end.
  52.  *
  53.  * @return {?string}
  54.  */
  55. shaka.util.TextParser.prototype.readLine = function() {
  56.   return this.readRegexReturnCapture_(/(.*?)(\n|$)/gm, 1);
  57. };
  60. /**
  61.  * Reads a word from the parser.  This will not read or return any whitespace
  62.  * before or after the word (including newlines).  Returns null at the end.
  63.  *
  64.  * @return {?string}
  65.  */
  66. shaka.util.TextParser.prototype.readWord = function() {
  67.   return this.readRegexReturnCapture_(/[^ \t\n]*/gm, 0);
  68. };
  71. /**
  72.  * Skips any continuous whitespace from the parser.  Returns null at the end.
  73.  */
  74. shaka.util.TextParser.prototype.skipWhitespace = function() {
  75.   this.readRegex(/[ \t]+/gm);
  76. };
  79. /**
  80.  * Reads the given regular expression from the parser.  This requires the match
  81.  * to be at the current position; there is no need to include a head anchor.
  82.  * This requires that the regex have the global flag to be set so that it can
  83.  * set lastIndex to start the search at the current position.  Returns null at
  84.  * the end or if the regex does not match the current position.
  85.  *
  86.  * @param {!RegExp} regex
  87.  * @return {Array.<string>}
  88.  */
  89. shaka.util.TextParser.prototype.readRegex = function(regex) {
  90.   let index = this.indexOf_(regex);
  91.   if (this.atEnd() || index == null || index.position != this.position_) {
  92.     return null;
  93.   }
  95.   this.position_ += index.length;
  96.   return index.results;
  97. };
  100. /**
  101.  * Reads a regex from the parser and returns the given capture.
  102.  *
  103.  * @param {!RegExp} regex
  104.  * @param {number} index
  105.  * @return {?string}
  106.  * @private
  107.  */
  108. shaka.util.TextParser.prototype.readRegexReturnCapture_ = function(
  109.     regex, index) {
  110.   if (this.atEnd()) {
  111.     return null;
  112.   }
  114.   let ret = this.readRegex(regex);
  115.   if (!ret) {
  116.     return null;
  117.   } else {
  118.     return ret[index];
  119.   }
  120. };
  123. /**
  124.  * Returns the index info about a regular expression match.
  125.  *
  126.  * @param {!RegExp} regex
  127.  * @return {?{position: number, length: number, results: !Array.<string>}}
  128.  * @private
  129.  */
  130. shaka.util.TextParser.prototype.indexOf_ = function(regex) {
  131.   // The global flag is required to use lastIndex.
  132.   goog.asserts.assert(regex.global, 'global flag should be set');
  134.   regex.lastIndex = this.position_;
  135.   let results = regex.exec(this.data_);
  136.   if (results == null) {
  137.     return null;
  138.   } else {
  139.     return {
  140.       position: results.index,
  141.       length: results[0].length,
  142.       results: results
  143.     };
  144.   }
  145. };