Source file parser_skip.ml

type token =
  | TUnknown of (Parse_info.t)
  | EOF of (Parse_info.t)
  | TCommentSpace of (Parse_info.t)
  | TCommentNewline of (Parse_info.t)
  | TComment of (Parse_info.t)
  | TInt of (string * Parse_info.t)
  | TFloat of (string * Parse_info.t)
  | TChar of (string * Parse_info.t)
  | TString of (string * Parse_info.t)
  | TLowerIdent of (string * Parse_info.t)
  | TUpperIdent of (string * Parse_info.t)
  | Tconst of (Parse_info.t)
  | Tfun of (Parse_info.t)
  | Talias of (Parse_info.t)
  | Tasync of (Parse_info.t)
  | Tawait of (Parse_info.t)
  | Ttry of (Parse_info.t)
  | Tcatch of (Parse_info.t)
  | Tclass of (Parse_info.t)
  | Ttrait of (Parse_info.t)
  | Textends of (Parse_info.t)
  | Tchildren of (Parse_info.t)
  | Tfinal of (Parse_info.t)
  | Tprivate of (Parse_info.t)
  | Tprotected of (Parse_info.t)
  | Tthis of (Parse_info.t)
  | Tif of (Parse_info.t)
  | Telse of (Parse_info.t)
  | Tmatch of (Parse_info.t)
  | Tfrom of (Parse_info.t)
  | Tmodule of (Parse_info.t)
  | Tmutable of (Parse_info.t)
  | Tnative of (Parse_info.t)
  | Tuses of (Parse_info.t)
  | Tstatic of (Parse_info.t)
  | Tthrow of (Parse_info.t)
  | Tas of (Parse_info.t)
  | Ttype of (Parse_info.t)
  | Tvoid of (Parse_info.t)
  | Twatch of (Parse_info.t)
  | Twhen of (Parse_info.t)
  | Twith of (Parse_info.t)
  | Tbase of (Parse_info.t)
  | Tcapture of (Parse_info.t)
  | Tdefault of (Parse_info.t)
  | Tdeferred of (Parse_info.t)
  | Tinst of (Parse_info.t)
  | TnonNullable of (Parse_info.t)
  | Tuntracked of (Parse_info.t)
  | Tvalue of (Parse_info.t)
  | Ttrue of (Parse_info.t)
  | Tfalse of (Parse_info.t)
  | Toverridable of (Parse_info.t)
  | Treadonly of (Parse_info.t)
  | Tmacro of (Parse_info.t)
  | Tfor of (Parse_info.t)
  | Tin of (Parse_info.t)
  | Textension of (Parse_info.t)
  | Tyield of (Parse_info.t)
  | Tbreak of (Parse_info.t)
  | Tcontinue of (Parse_info.t)
  | Tmemoized of (Parse_info.t)
  | Tfrozen of (Parse_info.t)
  | Tdo of (Parse_info.t)
  | Twhile of (Parse_info.t)
  | Tloop of (Parse_info.t)
  | TEq of (Parse_info.t)
  | TEqDot of (Parse_info.t)
  | TOParen of (Parse_info.t)
  | TCParen of (Parse_info.t)
  | TOBrace of (Parse_info.t)
  | TCBrace of (Parse_info.t)
  | TOBracket of (Parse_info.t)
  | TCBracket of (Parse_info.t)
  | TDot of (Parse_info.t)
  | TArrow of (Parse_info.t)
  | TTildeArrow of (Parse_info.t)
  | TEqualArrow of (Parse_info.t)
  | TComma of (Parse_info.t)
  | TColon of (Parse_info.t)
  | TColonColon of (Parse_info.t)
  | TSemiColon of (Parse_info.t)
  | TSemiColonSemiColon of (Parse_info.t)
  | TPipe of (Parse_info.t)
  | TQuestion of (Parse_info.t)
  | TAt of (Parse_info.t)
  | TSharp of (Parse_info.t)
  | TDollar of (Parse_info.t)
  | TBackquote of (Parse_info.t)
  | TPlus of (Parse_info.t)
  | TMinus of (Parse_info.t)
  | TStar of (Parse_info.t)
  | TDiv of (Parse_info.t)
  | TMod of (Parse_info.t)
  | TEqEq of (Parse_info.t)
  | TBangEq of (Parse_info.t)
  | TLess of (Parse_info.t)
  | TGreater of (Parse_info.t)
  | TLessEq of (Parse_info.t)
  | TGreaterEq of (Parse_info.t)
  | TAnd of (Parse_info.t)
  | THat of (Parse_info.t)
  | TBang of (Parse_info.t)
  | TAndAnd of (Parse_info.t)
  | TPipePipe of (Parse_info.t)

open Parsing;;
let _ = parse_error;;
# 2 "parser_skip.mly"
(* Yoann Padioleau
 *
 * Copyright (C) 2019 Yoann Padioleau
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * version 2.1 as published by the Free Software Foundation, with the
 * special exception on linking described in file license.txt.
 * 
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the file
 * license.txt for more details.
 *)
(* 
 *)

# 129 "parser_skip.ml"
let yytransl_const = [|
    0|]

let yytransl_block = [|
  257 (* TUnknown *);
    0 (* EOF *);
  258 (* TCommentSpace *);
  259 (* TCommentNewline *);
  260 (* TComment *);
  261 (* TInt *);
  262 (* TFloat *);
  263 (* TChar *);
  264 (* TString *);
  265 (* TLowerIdent *);
  266 (* TUpperIdent *);
  267 (* Tconst *);
  268 (* Tfun *);
  269 (* Talias *);
  270 (* Tasync *);
  271 (* Tawait *);
  272 (* Ttry *);
  273 (* Tcatch *);
  274 (* Tclass *);
  275 (* Ttrait *);
  276 (* Textends *);
  277 (* Tchildren *);
  278 (* Tfinal *);
  279 (* Tprivate *);
  280 (* Tprotected *);
  281 (* Tthis *);
  282 (* Tif *);
  283 (* Telse *);
  284 (* Tmatch *);
  285 (* Tfrom *);
  286 (* Tmodule *);
  287 (* Tmutable *);
  288 (* Tnative *);
  289 (* Tuses *);
  290 (* Tstatic *);
  291 (* Tthrow *);
  292 (* Tas *);
  293 (* Ttype *);
  294 (* Tvoid *);
  295 (* Twatch *);
  296 (* Twhen *);
  297 (* Twith *);
  298 (* Tbase *);
  299 (* Tcapture *);
  300 (* Tdefault *);
  301 (* Tdeferred *);
  302 (* Tinst *);
  303 (* TnonNullable *);
  304 (* Tuntracked *);
  305 (* Tvalue *);
  306 (* Ttrue *);
  307 (* Tfalse *);
  308 (* Toverridable *);
  309 (* Treadonly *);
  310 (* Tmacro *);
  311 (* Tfor *);
  312 (* Tin *);
  313 (* Textension *);
  314 (* Tyield *);
  315 (* Tbreak *);
  316 (* Tcontinue *);
  317 (* Tmemoized *);
  318 (* Tfrozen *);
  319 (* Tdo *);
  320 (* Twhile *);
  321 (* Tloop *);
  322 (* TEq *);
  323 (* TEqDot *);
  324 (* TOParen *);
  325 (* TCParen *);
  326 (* TOBrace *);
  327 (* TCBrace *);
  328 (* TOBracket *);
  329 (* TCBracket *);
  330 (* TDot *);
  331 (* TArrow *);
  332 (* TTildeArrow *);
  333 (* TEqualArrow *);
  334 (* TComma *);
  335 (* TColon *);
  336 (* TColonColon *);
  337 (* TSemiColon *);
  338 (* TSemiColonSemiColon *);
  339 (* TPipe *);
  340 (* TQuestion *);
  341 (* TAt *);
  342 (* TSharp *);
  343 (* TDollar *);
  344 (* TBackquote *);
  345 (* TPlus *);
  346 (* TMinus *);
  347 (* TStar *);
  348 (* TDiv *);
  349 (* TMod *);
  350 (* TEqEq *);
  351 (* TBangEq *);
  352 (* TLess *);
  353 (* TGreater *);
  354 (* TLessEq *);
  355 (* TGreaterEq *);
  356 (* TAnd *);
  357 (* THat *);
  358 (* TBang *);
  359 (* TAndAnd *);
  360 (* TPipePipe *);
    0|]

let yylhs = "\255\255\
\001\000\000\000"

let yylen = "\002\000\
\001\000\002\000"

let yydefred = "\000\000\
\000\000\000\000\001\000\002\000"

let yydgoto = "\002\000\
\004\000"

let yysindex = "\255\255\
\001\000\000\000\000\000\000\000"

let yyrindex = "\000\000\
\000\000\000\000\000\000\000\000"

let yygindex = "\000\000\
\000\000"

let yytablesize = 1
let yytable = "\001\000\
\003\000"

let yycheck = "\001\000\
\000\000"

let yynames_const = "\
  "

let yynames_block = "\
  TUnknown\000\
  EOF\000\
  TCommentSpace\000\
  TCommentNewline\000\
  TComment\000\
  TInt\000\
  TFloat\000\
  TChar\000\
  TString\000\
  TLowerIdent\000\
  TUpperIdent\000\
  Tconst\000\
  Tfun\000\
  Talias\000\
  Tasync\000\
  Tawait\000\
  Ttry\000\
  Tcatch\000\
  Tclass\000\
  Ttrait\000\
  Textends\000\
  Tchildren\000\
  Tfinal\000\
  Tprivate\000\
  Tprotected\000\
  Tthis\000\
  Tif\000\
  Telse\000\
  Tmatch\000\
  Tfrom\000\
  Tmodule\000\
  Tmutable\000\
  Tnative\000\
  Tuses\000\
  Tstatic\000\
  Tthrow\000\
  Tas\000\
  Ttype\000\
  Tvoid\000\
  Twatch\000\
  Twhen\000\
  Twith\000\
  Tbase\000\
  Tcapture\000\
  Tdefault\000\
  Tdeferred\000\
  Tinst\000\
  TnonNullable\000\
  Tuntracked\000\
  Tvalue\000\
  Ttrue\000\
  Tfalse\000\
  Toverridable\000\
  Treadonly\000\
  Tmacro\000\
  Tfor\000\
  Tin\000\
  Textension\000\
  Tyield\000\
  Tbreak\000\
  Tcontinue\000\
  Tmemoized\000\
  Tfrozen\000\
  Tdo\000\
  Twhile\000\
  Tloop\000\
  TEq\000\
  TEqDot\000\
  TOParen\000\
  TCParen\000\
  TOBrace\000\
  TCBrace\000\
  TOBracket\000\
  TCBracket\000\
  TDot\000\
  TArrow\000\
  TTildeArrow\000\
  TEqualArrow\000\
  TComma\000\
  TColon\000\
  TColonColon\000\
  TSemiColon\000\
  TSemiColonSemiColon\000\
  TPipe\000\
  TQuestion\000\
  TAt\000\
  TSharp\000\
  TDollar\000\
  TBackquote\000\
  TPlus\000\
  TMinus\000\
  TStar\000\
  TDiv\000\
  TMod\000\
  TEqEq\000\
  TBangEq\000\
  TLess\000\
  TGreater\000\
  TLessEq\000\
  TGreaterEq\000\
  TAnd\000\
  THat\000\
  TBang\000\
  TAndAnd\000\
  TPipePipe\000\
  "

let yyact = [|
  (fun _ -> failwith "parser")
; (fun __caml_parser_env ->
    let _1 = (Parsing.peek_val __caml_parser_env 0 : Parse_info.t) in
    Obj.repr(
# 135 "parser_skip.mly"
                                      ( raise Parsing.Parse_error )
# 387 "parser_skip.ml"
               : Ast_skip.program))
(* Entry main *)
; (fun __caml_parser_env -> raise (Parsing.YYexit (Parsing.peek_val __caml_parser_env 0)))
|]
let yytables =
  { Parsing.actions=yyact;
    Parsing.transl_const=yytransl_const;
    Parsing.transl_block=yytransl_block;
    Parsing.lhs=yylhs;
    Parsing.len=yylen;
    Parsing.defred=yydefred;
    Parsing.dgoto=yydgoto;
    Parsing.sindex=yysindex;
    Parsing.rindex=yyrindex;
    Parsing.gindex=yygindex;
    Parsing.tablesize=yytablesize;
    Parsing.table=yytable;
    Parsing.check=yycheck;
    Parsing.error_function=parse_error;
    Parsing.names_const=yynames_const;
    Parsing.names_block=yynames_block }
let main (lexfun : Lexing.lexbuf -> token) (lexbuf : Lexing.lexbuf) =
   (Parsing.yyparse yytables 1 lexfun lexbuf : Ast_skip.program)