Tryag File Manager

/home/yanggyein/yanggyein/yang_ai/node_modules/ret/lib/index.js

var util      = require('./util');
var types     = require('./types');
var sets      = require('./sets');
var positions = require('./positions');

module.exports = function(regexpStr) {
  var i = 0, l, c,
      start = { type: types.ROOT, stack: []},

// Keep track of last clause/group and stack.
      lastGroup = start,
      last = start.stack,
      groupStack = [];

var repeatErr = function(i) {
    util.error(regexpStr, 'Nothing to repeat at column ' + (i - 1));
  };

// Decode a few escaped characters.
  var str = util.strToChars(regexpStr);
  l = str.length;

// Iterate through each character in string.
  while (i < l) {
    c = str[i++];

switch (c) {
      // Handle escaped characters, inclues a few sets.
      case '\\':
        c = str[i++];

switch (c) {
          case 'b':
            last.push(positions.wordBoundary());
            break;

case 'B':
            last.push(positions.nonWordBoundary());
            break;

case 'w':
            last.push(sets.words());
            break;

case 'W':
            last.push(sets.notWords());
            break;

case 'd':
            last.push(sets.ints());
            break;

case 'D':
            last.push(sets.notInts());
            break;

case 's':
            last.push(sets.whitespace());
            break;

case 'S':
            last.push(sets.notWhitespace());
            break;

default:
            // Check if c is integer.
            // In which case it's a reference.
            if (/\d/.test(c)) {
              last.push({ type: types.REFERENCE, value: parseInt(c, 10) });

// Escaped character.
            } else {
              last.push({ type: types.CHAR, value: c.charCodeAt(0) });
            }
        }

break;

// Positionals.
      case '^':
          last.push(positions.begin());
        break;

case '$':
          last.push(positions.end());
        break;

// Handle custom sets.
      case '[':
        // Check if this class is 'anti' i.e. [^abc].
        var not;
        if (str[i] === '^') {
          not = true;
          i++;
        } else {
          not = false;
        }

// Get all the characters in class.
        var classTokens = util.tokenizeClass(str.slice(i), regexpStr);

// Increase index by length of class.
        i += classTokens[1];
        last.push({
          type: types.SET,
          set: classTokens[0],
          not: not,
        });

break;

// Class of any character except \n.
      case '.':
        last.push(sets.anyChar());
        break;

// Push group onto stack.
      case '(':
        // Create group.
        var group = {
          type: types.GROUP,
          stack: [],
          remember: true,
        };

c = str[i];

// If if this is a special kind of group.
        if (c === '?') {
          c = str[i + 1];
          i += 2;

// Match if followed by.
          if (c === '=') {
            group.followedBy = true;

// Match if not followed by.
          } else if (c === '!') {
            group.notFollowedBy = true;

} else if (c !== ':') {
            util.error(regexpStr,
              'Invalid group, character \'' + c +
              '\' after \'?\' at column ' + (i - 1));
          }

group.remember = false;
        }

// Insert subgroup into current group stack.
        last.push(group);

// Remember the current group for when the group closes.
        groupStack.push(lastGroup);

// Make this new group the current group.
        lastGroup = group;
        last = group.stack;
        break;

// Pop group out of stack.
      case ')':
        if (groupStack.length === 0) {
          util.error(regexpStr, 'Unmatched ) at column ' + (i - 1));
        }
        lastGroup = groupStack.pop();

// Check if this group has a PIPE.
        // To get back the correct last stack.
        last = lastGroup.options ?
          lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
        break;

// Use pipe character to give more choices.
      case '|':
        // Create array where options are if this is the first PIPE
        // in this clause.
        if (!lastGroup.options) {
          lastGroup.options = [lastGroup.stack];
          delete lastGroup.stack;
        }

// Create a new stack and add to options for rest of clause.
        var stack = [];
        lastGroup.options.push(stack);
        last = stack;
        break;

// Repetition.
      // For every repetition, remove last element from last stack
      // then insert back a RANGE object.
      // This design is chosen because there could be more than
      // one repetition symbols in a regex i.e. `a?+{2,3}`.
      case '{':
        var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), min, max;
        if (rs !== null) {
          if (last.length === 0) {
            repeatErr(i);
          }
          min = parseInt(rs[1], 10);
          max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
          i += rs[0].length;

last.push({
            type: types.REPETITION,
            min: min,
            max: max,
            value: last.pop(),
          });
        } else {
          last.push({
            type: types.CHAR,
            value: 123,
          });
        }
        break;

case '?':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 0,
          max: 1,
          value: last.pop(),
        });
        break;

case '+':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 1,
          max: Infinity,
          value: last.pop(),
        });
        break;

case '*':
        if (last.length === 0) {
          repeatErr(i);
        }
        last.push({
          type: types.REPETITION,
          min: 0,
          max: Infinity,
          value: last.pop(),
        });
        break;

// Default is a character that is not `\[](){}?+*^$`.
      default:
        last.push({
          type: types.CHAR,
          value: c.charCodeAt(0),
        });
    }

}

// Check if any groups have not been closed.
  if (groupStack.length !== 0) {
    util.error(regexpStr, 'Unterminated group');
  }

return start;
};

module.exports.types = types;