peg2 0.1.23 copy "peg2: ^0.1.23" to clipboard
peg2: ^0.1.23 copied to clipboard

discontinuedreplaced by: peg
outdated

PEG+ (Parsing expression grammar) parser source code generator, command line tool.

example/example.dart

// Generated by 'peg2'
// https://pub.dev/packages/peg2

void main() {
  final parser = ExampleParser();
  final result = parser.parse(_text);
  if (parser.error != null) {
    throw parser.error;
  }

  print(result);
}

final _text = '''
{"rocket": "🚀 flies to the stars"}
''';

class ExampleParser {
  static const _eof = 0x110000;

  FormatException error;

  int _c;

  int _error;

  List<String> _expected;

  int _failure;

  List<int> _input;

  List<bool> _memoizable;

  List<List<_Memo>> _memos;

  var _mresult;

  int _pos;

  bool _predicate;

  dynamic _result;

  bool _success;

  String _text;

  List<int> _trackCid;

  List<int> _trackPos;

  dynamic parse(String text) {
    if (text == null) {
      throw ArgumentError.notNull('text');
    }
    _text = text;
    _input = _toRunes(text);
    _reset();
    final result = _parseJson(0, true);
    _buildError();
    _expected = null;
    _input = null;
    return result;
  }

  void _buildError() {
    if (_success) {
      error = null;
      return;
    }

    String escape(int c) {
      switch (c) {
        case 10:
          return r'\n';
        case 13:
          return r'\r';
        case 09:
          return r'\t';
        case _eof:
          return 'end of file';
      }
      return String.fromCharCode(c);
    }

    String getc(int position) {
      if (position < _text.length) {
        return "'${escape(_input[position])}'";
      }
      return 'end of file';
    }

    String report(String message, String source, int start) {
      if (start < 0 || start > source.length) {
        start = null;
      }

      final sb = StringBuffer();
      sb.write(message);
      var line = 0;
      var col = 0;
      var lineStart = 0;
      var started = false;
      if (start != null) {
        for (var i = 0; i < source.length; i++) {
          final c = source.codeUnitAt(i);
          if (!started) {
            started = true;
            lineStart = i;
            line++;
            col = 1;
          } else {
            col++;
          }
          if (c == 10) {
            started = false;
          }
          if (start == i) {
            break;
          }
        }
      }

      if (start == null) {
        sb.writeln('.');
      } else if (line == 0 || start == source.length) {
        sb.write(' (at offset ');
        sb.write(start);
        sb.writeln('):');
      } else {
        sb.write(' (at line ');
        sb.write(line);
        sb.write(', column ');
        sb.write(col);
        sb.writeln('):');
      }

      List<int> escape(int c) {
        switch (c) {
          case 9:
            return [92, 116];
          case 10:
            return [92, 110];
          case 13:
            return [92, 114];
          default:
            return [c];
        }
      }

      const max = 70;
      if (start != null) {
        final c1 = <int>[];
        final c2 = <int>[];
        final half = max ~/ 2;
        var cr = false;
        for (var i = start; i >= lineStart && c1.length < half; i--) {
          if (i == source.length) {
            c2.insert(0, 94);
          } else {
            final c = source.codeUnitAt(i);
            final escaped = escape(c);
            c1.insertAll(0, escaped);
            if (c == 10) {
              cr = true;
            }

            final r = i == start ? 94 : 32;
            for (var k = 0; k < escaped.length; k++) {
              c2.insert(0, r);
            }
          }
        }

        for (var i = start + 1;
            i < source.length && c1.length < max && !cr;
            i++) {
          final c = source.codeUnitAt(i);
          final escaped = escape(c);
          c1.addAll(escaped);
          if (c == 10) {
            break;
          }
        }

        final text1 = String.fromCharCodes(c1);
        final text2 = String.fromCharCodes(c2);
        sb.writeln(text1);
        sb.writeln(text2);
      }

      return sb.toString();
    }

    final temp = _expected.toList();
    temp.sort((e1, e2) => e1.compareTo(e2));
    final expected = temp.toSet();
    final hasMalformed = false;
    if (expected.isNotEmpty) {
      if (!hasMalformed) {
        final sb = StringBuffer();
        sb.write('Expected ');
        sb.write(expected.join(', '));
        sb.write(' but found ');
        sb.write(getc(_error));
        final title = sb.toString();
        final message = report(title, _text, _error);
        error = FormatException(message);
      } else {
        final reason = _error == _text.length ? 'Unterminated' : 'Malformed';
        final sb = StringBuffer();
        sb.write(reason);
        sb.write(' ');
        sb.write(expected.join(', '));
        final title = sb.toString();
        final message = report(title, _text, _error);
        error = FormatException(message);
      }
    } else {
      final sb = StringBuffer();
      sb.write('Unexpected character ');
      sb.write(getc(_error));
      final title = sb.toString();
      final message = report(title, _text, _error);
      error = FormatException(message);
    }
  }

  void _fail(List<String> expected) {
    if (_error < _failure) {
      _error = _failure;
      _expected = [];
    }
    if (_error == _failure) {
      _expected.addAll(expected);
    }
  }

  int _matchRanges(List<int> ranges) {
    int result;
    _success = false;
    for (var i = 0; i < ranges.length; i += 2) {
      if (ranges[i] <= _c) {
        if (ranges[i + 1] >= _c) {
          result = _c;
          _c = _input[_pos += _c <= 0xffff ? 1 : 2];
          _success = true;
          break;
        }
      } else {
        break;
      }
    }

    if (!_success) {
      _failure = _pos;
    }

    return result;
  }

  String _matchString(String text) {
    String result;
    final length = text.length;
    final rest = _text.length - _pos;
    final count = length > rest ? rest : length;
    var pos = _pos;
    var i = 0;
    for (; i < count; i++, pos++) {
      if (text.codeUnitAt(i) != _text.codeUnitAt(pos)) {
        break;
      }
    }

    if (_success = i == length) {
      _c = _input[_pos += length];
      result = text;
    } else {
      _failure = _pos + i;
    }

    return result;
  }

  bool _memoized(int id, int cid) {
    final memos = _memos[_pos];
    if (memos != null) {
      for (var i = 0; i < memos.length; i++) {
        final memo = memos[i];
        if (memo.id == id) {
          _pos = memo.pos;
          _mresult = memo.result;
          _success = memo.success;
          _c = _input[_pos];
          return true;
        }
      }
    }

    if (_memoizable[cid] != null) {
      return false;
    }

    final lastCid = _trackCid[id];
    final lastPos = _trackPos[id];
    _trackCid[id] = cid;
    _trackPos[id] = _pos;
    if (lastCid == null) {
      return false;
    }

    if (lastPos == _pos) {
      if (lastCid != cid) {
        _memoizable[lastCid] = true;
        _memoizable[cid] = false;
      }
    }

    return false;
  }

  void _memoize(int id, int pos, result) {
    var memos = _memos[pos];
    if (memos == null) {
      memos = [];
      _memos[pos] = memos;
    }

    final memo = _Memo(
      id: id,
      pos: _pos,
      result: result,
      success: _success,
    );

    memos.add(memo);
  }

  void _reset() {
    _c = _input[0];
    _error = 0;
    _expected = [];
    _failure = -1;
    _memoizable = [];
    _memoizable.length = 183;
    _memos = [];
    _memos.length = _input.length + 1;
    _pos = 0;
    _predicate = false;
    _success = false;
    _trackCid = [];
    _trackCid.length = 183;
    _trackPos = [];
    _trackPos.length = 183;
  }

  List<int> _toRunes(String source) {
    final length = source.length;
    final result = List<int>(length + 1);
    for (var pos = 0; pos < length;) {
      int c;
      final start = pos;
      final leading = source.codeUnitAt(pos++);
      if ((leading & 0xFC00) == 0xD800 && pos < length) {
        final trailing = source.codeUnitAt(pos);
        if ((trailing & 0xFC00) == 0xDC00) {
          c = 0x10000 + ((leading & 0x3FF) << 10) + (trailing & 0x3FF);
          pos++;
        } else {
          c = leading;
        }
      } else {
        c = leading;
      }

      result[start] = c;
    }

    result[length] = 0x110000;
    return result;
  }

  dynamic _parseJson(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    final $04 = _c;
    dynamic $06;
    _parse_leading_spaces(3, false);
    final $011 = _parseValue(4, $01);
    if (_success) {
      _parse_end_of_file(5, false);
      if (_success) {
        $06 = $011;
      }
    }
    if (!_success) {
      _c = $04;
      _pos = $03;
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const [
        '\'false\'',
        '\'null\'',
        '\'true\'',
        '\'number\'',
        '\'string\'',
        '\'[\'',
        '\'{\''
      ]);
    }
    return $02;
  }

  dynamic _parseValue(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    for (;;) {
      List $06;
      final $09 = _parseArray(8, $01);
      if (_success) {
        $06 = $09;
        $02 = $06;
        break;
      }
      dynamic $010;
      final $013 = _parse_false(10, $01);
      if (_success) {
        $010 = $013;
        $02 = $010;
        break;
      }
      dynamic $014;
      final $017 = _parse_null(12, $01);
      if (_success) {
        $014 = $017;
        $02 = $014;
        break;
      }
      dynamic $018;
      final $021 = _parse_true(14, $01);
      if (_success) {
        $018 = $021;
        $02 = $018;
        break;
      }
      Map<String, dynamic> $022;
      final $025 = _parseObject(16, $01);
      if (_success) {
        $022 = $025;
        $02 = $022;
        break;
      }
      num $026;
      final $029 = _parse_number(18, $01);
      if (_success) {
        $026 = $029;
        $02 = $026;
        break;
      }
      String $030;
      final $033 = _parse_string(20, $01);
      if (_success) {
        $030 = $033;
        $02 = $030;
        break;
      }
      break;
    }
    if (!_success && _error == $03) {
      _fail(const [
        '\'false\'',
        '\'null\'',
        '\'true\'',
        '\'number\'',
        '\'string\'',
        '\'[\'',
        '\'{\''
      ]);
    }
    return $02;
  }

  List _parseArray(int $00, bool $01) {
    List $02;
    final $03 = _pos;
    final $04 = _c;
    List $06;
    _parse_$LeftSquareBracket(23, false);
    if (_success) {
      final $010 = _parseValues(25, $01);
      final $011 = $010;
      _parse_$RightSquareBracket(26, false);
      if (_success) {
        final v = $011;
        List $$;
        $$ = v ?? [];
        $06 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const ['\'[\'']);
    }
    return $02;
  }

  List _parseValues(int $00, bool $01) {
    List $02;
    final $03 = _pos;
    final $04 = _c;
    List $06;
    final $09 = _parseValue(29, $01);
    if (_success) {
      List $010;
      if ($01) {
        $010 = [];
      }
      for (;;) {
        dynamic $011;
        final $012 = _pos;
        final $014 = _c;
        dynamic $016;
        _parse_$Comma(33, false);
        if (_success) {
          final $020 = _parseValue(34, $01);
          if (_success) {
            $016 = $020;
          } else {
            _c = $014;
            _pos = $012;
          }
        }
        $011 = $016;
        if (!_success && _error == $012) {
          _fail(const ['\',\'']);
        }
        if (!_success) {
          _success = true;
          break;
        }
        if ($01) {
          $010.add($011);
        }
      }
      if (_success) {
        final v = $09;
        final n = $010;
        List $$;
        $$ = [v, ...n];
        $06 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const [
        '\'false\'',
        '\'null\'',
        '\'true\'',
        '\'number\'',
        '\'string\'',
        '\'[\'',
        '\'{\''
      ]);
    }
    return $02;
  }

  Map<String, dynamic> _parseObject(int $00, bool $01) {
    Map<String, dynamic> $02;
    final $03 = _pos;
    final $04 = _c;
    Map<String, dynamic> $06;
    _parse_$LeftBrace(37, false);
    if (_success) {
      final $010 = _parseMembers(39, $01);
      final $011 = $010;
      _parse_$RightBrace(40, false);
      if (_success) {
        final m = $011;
        Map<String, dynamic> $$;
        $$ = <String, dynamic>{}..addEntries(m ?? []);
        $06 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const ['\'{\'']);
    }
    return $02;
  }

  List<MapEntry<String, dynamic>> _parseMembers(int $00, bool $01) {
    List<MapEntry<String, dynamic>> $02;
    final $03 = _pos;
    final $04 = _c;
    List<MapEntry<String, dynamic>> $06;
    final $09 = _parseMember(43, $01);
    if (_success) {
      List<MapEntry<String, dynamic>> $010;
      if ($01) {
        $010 = [];
      }
      for (;;) {
        MapEntry<String, dynamic> $011;
        final $012 = _pos;
        final $014 = _c;
        MapEntry<String, dynamic> $016;
        _parse_$Comma(47, false);
        if (_success) {
          final $020 = _parseMember(48, $01);
          if (_success) {
            $016 = $020;
          } else {
            _c = $014;
            _pos = $012;
          }
        }
        $011 = $016;
        if (!_success && _error == $012) {
          _fail(const ['\',\'']);
        }
        if (!_success) {
          _success = true;
          break;
        }
        if ($01) {
          $010.add($011);
        }
      }
      if (_success) {
        final m = $09;
        final n = $010;
        List<MapEntry<String, dynamic>> $$;
        $$ = [m, ...n];
        $06 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const ['\'string\'']);
    }
    return $02;
  }

  MapEntry<String, dynamic> _parseMember(int $00, bool $01) {
    MapEntry<String, dynamic> $02;
    final $03 = _pos;
    final $04 = _c;
    MapEntry<String, dynamic> $06;
    final $09 = _parse_string(51, $01);
    if (_success) {
      _parse_$Colon(52, false);
      if (_success) {
        final $011 = _parseValue(53, $01);
        if (_success) {
          final k = $09;
          final v = $011;
          MapEntry<String, dynamic> $$;
          $$ = MapEntry(k, v);
          $06 = $$;
        }
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    if (!_success && _error == $03) {
      _fail(const ['\'string\'']);
    }
    return $02;
  }

  dynamic _parse_end_of_file(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    final $04 = _c;
    dynamic $07;
    final $012 = $01;
    $01 = false;
    if (_c >= 0 && _c <= 1114111) {
      _success = true;
      _c = _input[_pos += _c <= 65535 ? 1 : 2];
    } else {
      _success = false;
      _failure = _pos;
    }
    _success = !_success;
    _c = $04;
    _pos = $03;
    $01 = $012;
    var $014;
    if (_success) {
      $07 = $014;
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'end of file\'']);
    }
    return $02;
  }

  dynamic _parse_false(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    final $04 = _c;
    dynamic $07;
    if (_c == 102) {
      _matchString('false');
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(61, false);
      if (_success) {
        dynamic $$;
        $$ = false;
        $07 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'false\'']);
    }
    return $02;
  }

  List<int> _parse_leading_spaces(int $00, bool $01) {
    List<int> $02;
    $02 = _parse$$spacing(64, false);
    if (!_success && _error <= _failure) {
      _fail(const ['\'leading spaces\'']);
    }
    return $02;
  }

  dynamic _parse_null(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    final $04 = _c;
    dynamic $07;
    if (_c == 110) {
      _matchString('null');
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(68, false);
      if (_success) {
        dynamic $$;
        $$ = null;
        $07 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'null\'']);
    }
    return $02;
  }

  dynamic _parse_true(int $00, bool $01) {
    dynamic $02;
    final $03 = _pos;
    final $04 = _c;
    dynamic $07;
    if (_c == 116) {
      _matchString('true');
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(72, false);
      if (_success) {
        dynamic $$;
        $$ = true;
        $07 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'true\'']);
    }
    return $02;
  }

  String _parse_string(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    if (_c == 34) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      List<int> $011;
      if ($01) {
        $011 = [];
      }
      for (;;) {
        final $012 = _parse$$char(77, $01);
        if (!_success) {
          _success = true;
          break;
        }
        if ($01) {
          $011.add($012);
        }
      }
      if (_c == 34) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        _parse$$spacing(79, false);
        if (_success) {
          final c = $011;
          String $$;
          $$ = String.fromCharCodes(c);
          $07 = $$;
        }
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'string\'']);
    }
    return $02;
  }

  num _parse_number(int $00, bool $01) {
    num $02;
    final $03 = _pos;
    final $04 = _c;
    num $07;
    String $010;
    final $012 = $01;
    $01 = false;
    final $014 = _pos;
    final $016 = _c;
    if (_c == 45) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    final $025 = _pos;
    final $027 = _c;
    var $029 = _pos;
    for (;;) {
      if (_c == 48) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if ($029 < _failure) {
        $029 = _failure;
      }
      if (_success) {
        break;
      }
      final $035 = _c;
      final $036 = _pos;
      if (_c >= 49 && _c <= 57) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        for (;;) {
          if (_c >= 48 && _c <= 57) {
            _success = true;
            _c = _input[++_pos];
          } else {
            _success = false;
            _failure = _pos;
          }
          if (!_success) {
            _success = true;
            break;
          }
        }
        if (!_success) {
          _c = $035;
          _pos = $036;
        }
      }
      if ($029 < _failure) {
        $029 = _failure;
      }
      if (_success) {
        break;
      }
      _c = $027;
      _pos = $025;
      _failure = $029;
      break;
    }
    if (_success) {
      final $041 = _pos;
      final $043 = _c;
      if (_c == 46) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        var $051 = false;
        for (;;) {
          if (_c >= 48 && _c <= 57) {
            _success = true;
            _c = _input[++_pos];
          } else {
            _success = false;
            _failure = _pos;
          }
          if (!_success) {
            _success = $051;
            break;
          }
          $051 = true;
        }
        if (!_success) {
          _c = $043;
          _pos = $041;
        }
      }
      final $055 = _pos;
      final $057 = _c;
      if (_c == 69 || _c == 101) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        if (_c == 43 || _c == 45) {
          _success = true;
          _c = _input[++_pos];
        } else {
          _success = false;
          _failure = _pos;
        }
        var $067 = false;
        for (;;) {
          if (_c >= 48 && _c <= 57) {
            _success = true;
            _c = _input[++_pos];
          } else {
            _success = false;
            _failure = _pos;
          }
          if (!_success) {
            _success = $067;
            break;
          }
          $067 = true;
        }
        if (!_success) {
          _c = $057;
          _pos = $055;
        }
      }
      _success = true;
    }
    if (!_success) {
      _c = $016;
      _pos = $014;
    }
    if (_success) {
      $010 = _text.substring($03, _pos);
    }
    $01 = $012;
    if (_success) {
      _parse$$spacing(108, false);
      if (_success) {
        final n = $010;
        num $$;
        $$ = num.parse(n);
        $07 = $$;
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'number\'']);
    }
    return $02;
  }

  String _parse_$LeftBrace(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 123) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(112, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'{\'']);
    }
    return $02;
  }

  String _parse_$RightBrace(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 125) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(116, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'}\'']);
    }
    return $02;
  }

  String _parse_$LeftSquareBracket(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 91) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(120, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\'[\'']);
    }
    return $02;
  }

  String _parse_$RightSquareBracket(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 93) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(124, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\']\'']);
    }
    return $02;
  }

  String _parse_$Comma(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 44) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(128, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\',\'']);
    }
    return $02;
  }

  String _parse_$Colon(int $00, bool $01) {
    String $02;
    final $03 = _pos;
    final $04 = _c;
    String $07;
    String $010;
    if (_c == 58) {
      _success = true;
      _c = _input[++_pos];
    } else {
      _success = false;
      _failure = _pos;
    }
    if (_success) {
      _parse$$spacing(132, false);
      $07 = $010;
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $07;
    if (!_success && _error <= _failure) {
      _fail(const ['\':\'']);
    }
    return $02;
  }

  int _parse$$char(int $00, bool $01) {
    int $02;
    final $03 = _pos;
    final $04 = _c;
    for (;;) {
      int $06;
      final $07 = _c;
      final $08 = _pos;
      if (_c == 92) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        final $010 = _parse$$escaped(136, $01);
        if (_success) {
          $06 = $010;
        } else {
          _c = $07;
          _pos = $08;
        }
      }
      if (_success) {
        $02 = $06;
        break;
      }
      _c = $04;
      _pos = $03;
      int $011;
      final $014 = _parse$$unescaped(138, $01);
      if (_success) {
        $011 = $014;
        $02 = $011;
        break;
      }
      break;
    }
    return $02;
  }

  int _parse$$escaped(int $00, bool $01) {
    int $02;
    final $03 = _pos;
    final $04 = _c;
    for (;;) {
      int $06;
      int $09;
      if (_c == 34) {
        _success = true;
        $09 = _c;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $06 = $09;
        $02 = $06;
        break;
      }
      int $010;
      int $013;
      if (_c == 92) {
        _success = true;
        $013 = _c;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $010 = $013;
        $02 = $010;
        break;
      }
      int $014;
      int $017;
      if (_c == 47) {
        _success = true;
        $017 = _c;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $014 = $017;
        $02 = $014;
        break;
      }
      int $018;
      if (_c == 98) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = 0x8;
        $018 = $$;
      }
      if (_success) {
        $02 = $018;
        break;
      }
      int $022;
      if (_c == 102) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = 0xC;
        $022 = $$;
      }
      if (_success) {
        $02 = $022;
        break;
      }
      int $026;
      if (_c == 110) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = 0xA;
        $026 = $$;
      }
      if (_success) {
        $02 = $026;
        break;
      }
      int $030;
      if (_c == 114) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = 0xD;
        $030 = $$;
      }
      if (_success) {
        $02 = $030;
        break;
      }
      int $034;
      if (_c == 116) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = 0x9;
        $034 = $$;
      }
      if (_success) {
        $02 = $034;
        break;
      }
      int $038;
      final $039 = _c;
      final $040 = _pos;
      if (_c == 117) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        final $042 = _parse$$hexdig4(158, $01);
        if (_success) {
          $038 = $042;
        } else {
          _c = $039;
          _pos = $040;
        }
      }
      if (_success) {
        $02 = $038;
        break;
      }
      _c = $04;
      _pos = $03;
      break;
    }
    return $02;
  }

  int _parse$$hexdig4(int $00, bool $01) {
    int $02;
    final $03 = _pos;
    final $04 = _c;
    int $06;
    final $09 = _parse$$hexdig(161, $01);
    if (_success) {
      final $010 = _parse$$hexdig(162, $01);
      if (_success) {
        final $011 = _parse$$hexdig(163, $01);
        if (_success) {
          final $012 = _parse$$hexdig(164, $01);
          if (_success) {
            final a = $09;
            final b = $010;
            final c = $011;
            final d = $012;
            int $$;
            $$ = a * 0xfff + b * 0xff + c * 0xf + d;
            $06 = $$;
          }
        }
      }
      if (!_success) {
        _c = $04;
        _pos = $03;
      }
    }
    $02 = $06;
    return $02;
  }

  int _parse$$hexdig(int $00, bool $01) {
    int $02;
    for (;;) {
      int $06;
      if (_c >= 97 && _c <= 102) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = $$ - 97;
        $06 = $$;
      }
      if (_success) {
        $02 = $06;
        break;
      }
      int $010;
      if (_c >= 65 && _c <= 70) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = $$ - 65;
        $010 = $$;
      }
      if (_success) {
        $02 = $010;
        break;
      }
      int $014;
      if (_c >= 48 && _c <= 57) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        int $$;
        $$ = $$ - 48;
        $014 = $$;
      }
      if (_success) {
        $02 = $014;
        break;
      }
      break;
    }
    return $02;
  }

  int _parse$$unescaped(int $00, bool $01) {
    int $02;
    for (;;) {
      int $06;
      int $09;
      if (_c >= 32 && _c <= 33) {
        _success = true;
        $09 = _c;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $06 = $09;
        $02 = $06;
        break;
      }
      int $010;
      int $013;
      if (_c >= 35 && _c <= 91) {
        _success = true;
        $013 = _c;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $010 = $013;
        $02 = $010;
        break;
      }
      int $014;
      int $017;
      if (_c >= 93 && _c <= 1114111) {
        _success = true;
        $017 = _c;
        _c = _input[_pos += _c <= 65535 ? 1 : 2];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (_success) {
        $014 = $017;
        $02 = $014;
        break;
      }
      break;
    }
    return $02;
  }

  List<int> _parse$$spacing(int $00, bool $01) {
    List<int> $02;
    for (;;) {
      if (_c >= 9 && _c <= 10 || _c == 13 || _c == 32) {
        _success = true;
        _c = _input[++_pos];
      } else {
        _success = false;
        _failure = _pos;
      }
      if (!_success) {
        _success = true;
        break;
      }
    }
    return $02;
  }
}

class _Memo {
  final int id;

  final int pos;

  final result;

  final bool success;

  _Memo({
    this.id,
    this.pos,
    this.result,
    this.success,
  });
}

// ignore_for_file: unused_element
// ignore_for_file: unused_field
1
likes
0
pub points
0%
popularity

Publisher

unverified uploader

PEG+ (Parsing expression grammar) parser source code generator, command line tool.

Repository (GitHub)
View/report issues

License

unknown (LICENSE)

Dependencies

args, dart_style, lists, meta, path, strings

More

Packages that depend on peg2