More information:
http://www.nitlanguage.org
-
# FIXME : This huge `if` block is only necessary to copy primitive arrays as long as there's no better way to do it
if comment == "#" then
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
# Methods with return type
else if return_type != null then
- temp.add(" in \"Java\" `\{\n{comment}\t\treturn {jreturn_type.return_cast}recv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\treturn {jreturn_type.return_cast}self.{jmethod_id}({java_params});\n{comment}\t`\}\n")
# Methods without return type
else if jreturn_type.is_void then
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
# No copy
else
- temp.add(" in \"Java\" `\{\n{comment}\t\trecv.{jmethod_id}({java_params});\n{comment}\t`\}\n")
+ temp.add(" in \"Java\" `\{\n{comment}\t\tself.{jmethod_id}({java_params});\n{comment}\t`\}\n")
end
return temp.join("")
# The current values assigned to each variable
var vars = new HashMap[String, Int]
- redef fun visit(n) do n.accept_calculator(self)
+ redef fun visit(n) do n.accept_minilang(self)
end
redef class Node
# Execution of the node by the interpreter `v`
- fun accept_calculator(v: Interpretor) do visit_children(v)
+ fun accept_minilang(v: Interpretor) do visit_children(v)
end
redef class Nint
- redef fun accept_calculator(v) do v.stack.push(text.to_i)
+ redef fun accept_minilang(v) do v.stack.push(text.to_i)
end
redef class Ns_assign
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.vars[n_id.text] = v.stack.pop
end
end
redef class Ns_print
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
printn v.stack.pop
end
end
redef class Ns_print_str
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
var text = n_str.text
text = text.substring(1, text.length-2)
printn text
end
end
redef class Ns_println
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
print ""
end
end
redef class Ns_if
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
v.enter_visit(n_c)
if v.bstack.pop then
v.enter_visit(n_then)
end
end
redef class Ns_while
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
loop
v.enter_visit(n_c)
if not v.bstack.pop then break
redef class Nc_and
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
var b1 = v.bstack.pop
var b2 = v.bstack.pop
end
redef class Nc_or
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
var b1 = v.bstack.pop
var b2 = v.bstack.pop
end
redef class Nc_not
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(not v.bstack.pop)
end
end
redef class Nc_eq
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop == v.stack.pop)
end
end
redef class Nc_ne
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop != v.stack.pop)
end
end
redef class Nc_lt
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop > v.stack.pop)
end
end
redef class Nc_le
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop >= v.stack.pop)
end
end
redef class Nc_gt
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop < v.stack.pop)
end
end
redef class Nc_ge
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.bstack.push(v.stack.pop <= v.stack.pop)
end
end
redef class Ne_add
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.stack.push(v.stack.pop+v.stack.pop)
end
end
redef class Ne_sub
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
var n1 = v.stack.pop
v.stack.push(v.stack.pop-n1)
end
end
redef class Ne_neg
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.stack.push(-v.stack.pop)
end
end
redef class Ne_mul
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
v.stack.push(v.stack.pop*v.stack.pop)
end
end
redef class Ne_div
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
super
var n1 = v.stack.pop
v.stack.push(v.stack.pop/n1)
end
end
redef class Ne_var
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
v.stack.push v.vars[n_id.text]
end
end
redef class Ne_read
- redef fun accept_calculator(v) do
+ redef fun accept_minilang(v) do
var t = gets
v.stack.push(t.to_i)
end
# List markdown source files from a directory.
fun list_md_files(dir: String): Array[String] do
var files = new Array[String]
- var pipe = new ProcessReader("find", dir, "-name", "*.md")
+ var pipe = new ProcessReader("find", dir, "-name", "*.{config.md_ext}")
while not pipe.eof do
var file = pipe.read_line
if file == "" then break # last line
- var name = file.basename(".md")
+ var name = file.basename(".{config.md_ext}")
if name == "header" or name == "footer" or name == "menu" then continue
files.add file
end
#
# REQUIRE: `has_template`
fun load_template(name: String): TemplateString do
- assert has_template(name)
+ if not has_template(name) then
+ message("Error: can't load template `{name}`", 0)
+ exit 1
+ end
var file = expand_path(config.root_dir, config.templates_dir, name)
var tpl = new TemplateString.from_file(file)
if tpl.has_macro("ROOT_URL") then
# Create a new article using a markdown source file.
init from_source(wiki: Nitiwiki, md_file: String) do
src_full_path = md_file
- init(wiki, md_file.basename(".md"))
+ init(wiki, md_file.basename(".{wiki.config.md_ext}"))
content = md
end
# * default: `http://localhost/`
var root_url: String is lazy do return value_or_default("wiki.root_url", "http://localhost/")
+ # Markdown extension recognized by this wiki.
+ #
+ # We allow only one kind of extension per wiki.
+ # Files with other markdown extensions will be treated as resources.
+ #
+ # * key: `wiki.md_ext`
+ # * default: `md`
+ var md_ext: String is lazy do return value_or_default("wiki.md_ext", "md")
# Root directory of the wiki.
#
module wiki_html
import wiki_links
+import markdown::decorators
redef class Nitiwiki
sitemap.is_dirty = true
return sitemap
end
+
+ # Markdown processor used for inline element such as titles in TOC.
+ private var inline_processor: MarkdownProcessor is lazy do
+ var proc = new MarkdownProcessor
+ proc.emitter.decorator = new InlineDecorator
+ return proc
+ end
+
+ # Inline markdown (remove h1, p, ... elements).
+ private fun inline_md(md: Writable): Writable do
+ return inline_processor.process(md.write_to_string)
+ end
end
redef class WikiEntry
while iter.is_ok do
var hl = iter.item
# parse title as markdown
- var title = hl.title.md_to_html.to_s
- title = title.substring(3, title.length - 8)
+ var title = wiki.inline_md(hl.title)
tpl.add "<li><a href=\"#{hl.id}\">{title}</a>"
iter.next
if iter.is_ok then
--- /dev/null
+Render section out
--- /dev/null
+nitiWiki
+name: wiki3
+config: wiki3/config.ini
+url: http://localhost/
+
+There is modified files:
+ + pages
+ + /pages/contact.mdwn
+ + /pages/index.mdwn
+ + /pages/other_page.mdwn
+
+Use nitiwiki --render to render modified files
--- /dev/null
+wiki.name=wiki3
+wiki.root_dir=wiki3
+wiki.md_ext=mdwn
--- /dev/null
+# Other Page
--- /dev/null
+<div class="row footer">
+ <div class="container-fluid">
+ <div class="well well-sm">
+ <p><strong>%TITLE% © %YEAR%</strong></p>
+ <p class="text-muted"><em>last modification %GEN_TIME%</em></p>
+ <p class="text-muted">Proudly powered by
+ <a href="http://nitlanguage.org">nit</a>!</p>
+ </div>
+ </div>
+</div>
--- /dev/null
+<div class="container-fluid header">
+ <div class="container">
+ <div class="header">
+ <a href="http://uqam.ca"><img src="%ROOT_URL%/%LOGO%" alt="logo" /></a>
+ <h2>%SUBTITLE%</h2>
+ <h1>%TITLE%</h1>
+ </div>
+ </div>
+</div>
--- /dev/null
+<nav class="menu" role="navigation">
+ <div class="container">
+ <!-- Brand and toggle get grouped for better mobile display -->
+ <div class="navbar-header">
+ <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
+ <span class="sr-only">Toggle navigation</span>
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ <span class="icon-bar"></span>
+ </button>
+ <a class="navbar-brand" href="%ROOT_URL%index.html">%TITLE%</a>
+ </div>
+ <!-- Collect the nav links, forms, and other content for toggling -->
+ <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
+ <ul class="nav navbar-nav">
+ %MENUS%
+ </ul>
+ </div><!-- /.navbar-collapse -->
+ </div>
+</nav>
--- /dev/null
+<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <meta charset="utf-8">
+ <meta http-equiv="X-UA-Compatible" content="IE=edge">
+ <meta name="viewport" content="width=device-width, initial-scale=1">
+ <title>%TITLE%</title>
+
+ <link href="%ROOT_URL%/assets/vendors/bootstrap/bootstrap-3.2.0-dist/css/bootstrap.min.css" rel="stylesheet">
+ <link href="%ROOT_URL%/assets/css/main.css" rel="stylesheet">
+
+ <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
+ <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
+ <!--[if lt IE 9]>
+ <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
+ <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
+ <![endif]-->
+ </head>
+ <body>
+ %HEADER%
+ %TOP_MENU%
+ <div class="container">
+ <div class="row">
+ %BODY%
+ </div>
+ %FOOTER%
+ </div>
+
+ <script src="%ROOT_URL%/vendors/jquery/jquery-1.11.1.min.js"></script>
+ <script src="%ROOT_URL%/vendors/bootstrap/bootstrap-3.2.0-dist/js/bootstrap.min.js"></script>
+ </body>
+</html>
--- /dev/null
+../bin/nitiwiki --config wiki3/config.ini --clean --render -v
--- /dev/null
+../bin/nitiwiki --config wiki3/config.ini --clean --status
--- /dev/null
+bin/header_static:
+ mkdir -p bin
+ ../../../bin/nitc --dir bin src/header_static.nit
+
+tests: bin/header_static
+ cat CGGeometry.h | bin/header_static > static_CGGeometry.h
+ cat NSObject.h | bin/header_static > static_NSObject.h
--- /dev/null
+# This file is part of NIT (http://www.nitlanguage.org).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Filters preprocessed C-like header files to remove static code and keep their signatures.
+#
+# This tool is used in the process of parsing header files to extract
+# information on the declared services (the functions and structures).
+# This information is then used to generate bindings for Nit code
+# to access these services.
+#
+# The C header sometimes contains static code. It deletes static code of
+# headers, but keep their signatures. This tool is an extension of
+# header_keeper. It searches the keyword static to identify
+# the static code, and ignores the code into their brackets. The result is
+# printed to sdtout.
+#
+# ~~~sh
+# cat Pre-Processed/CGGeometry.h | header_static > Pre-Processed/static_header.h
+# ~~~
+#
+# This module can also be used as a library.
+# The main service is the method `header_static`
+module header_static
+
+redef class Char
+ private fun is_endline: Bool do return "\};".has(self)
+end
+
+# Filters the preprocessed `input` to keep signatures for static code and write to the `output`
+fun header_static(input: Reader, output: Writer) do
+ var static_target = false
+ var static_attribute_target = false
+ var bracket_counter = 0
+ var previous_letter = ""
+ var instruction = ""
+ var double_underscore = 0
+ var position = 0
+
+ while not input.eof do
+ var line = input.read_line
+ if line.to_s.has("static") then static_target = true
+
+ if static_target then
+ if line.to_s.has("__attribute__") then static_attribute_target = true
+ for letter in line do
+ if letter == '{' then bracket_counter += 1
+ if letter == '}' then bracket_counter -= 1
+
+ if letter == '_' and previous_letter == "_" and bracket_counter == 0 then
+ double_underscore += 1
+ end
+
+ # Sometimes we lost space between return type and signature name,
+ # because he has a return line between both.
+ # We add a space before signature name for safety.
+ if bracket_counter == 0 and letter == '_' and double_underscore >= 1 and not static_attribute_target then
+ instruction = instruction.insert_at(" ", position - 2)
+ end
+ if bracket_counter == 0 and not letter.is_endline then instruction += letter.to_s
+ if bracket_counter == 0 and letter.is_endline then
+ instruction += ";"
+ static_target = false
+ static_attribute_target = false
+ end
+
+ if bracket_counter == 0 and (letter == '}' and double_underscore >= 1 or letter == ';') then
+ output.write instruction + "\n"
+ end
+
+ if letter.is_endline and bracket_counter == 0 then
+ double_underscore = 0
+ position = 0
+ instruction = ""
+ end
+
+ previous_letter = letter.to_s
+ position += 1
+ end
+ else
+ output.write line + "\n"
+ end
+ end
+end
+
+header_static(sys.stdin, sys.stdout)
self.path = path
var file = sys.files[path]
prepare_buffer(file.length)
- _buffer.append(file)
+ path.copy_to_native(_buffer, file.length, 0, 0)
end
redef fun close
redef fun fill_buffer
do
- _buffer.clear
+ buffer_reset
end_reached = true
end
.nit.sablecc3: Sablecc3 grammar after processing
.nit.sablecc3.dump: Dump of the grammar to improve sablecc3 multiple runs
.parser-nofact.nit: The parser generated by SableCC3 before factorization by fact_parser.pl
-
# Returns null on success
fun file_rename_to(dest: String): nullable String import String.to_cstring,
NativeString.to_s, String.as nullable `{
- int res = rename(String_to_cstring(recv), String_to_cstring(dest));
+ int res = rename(String_to_cstring(self), String_to_cstring(dest));
if (res == 0) return null_String();
return String_as_nullable(NativeString_to_s(strerror(errno)));
`}
`}
# The pin `id` depends on wiringPi setup used
- fun id: Int `{ return recv->id; `}
+ fun id: Int `{ return self->id; `}
# Sets the mode of the pin
- fun mode(mode: RPiPinMode) `{ pinMode(recv->id, mode); `}
+ fun mode(mode: RPiPinMode) `{ pinMode(self->id, mode); `}
# This sets the pull-up or pull-down resistor mode on the given pin,
# which should be set as an input.
- fun pullup_dncontrol(pud: PUDControl) `{ pullUpDnControl(recv->id, pud); `}
+ fun pullup_dncontrol(pud: PUDControl) `{ pullUpDnControl(self->id, pud); `}
# Writes the value HIGH or LOW (true or false) to the given pin which must
# have been previously set as an output.
- fun write(high: Bool) `{ digitalWrite(recv->id, high? HIGH: LOW); `}
+ fun write(high: Bool) `{ digitalWrite(self->id, high? HIGH: LOW); `}
# Writes the value to the PWM register for the given pin.
# The Raspberry Pi has one on-board PWM pin, pin 1 (BMC_GPIO 18, Phys 12)
# and the range is 0-1024.
# Other PWM devices may have other PWM ranges.
- fun pwm_write(value: Int) `{ pwmWrite(recv->id, value); `}
+ fun pwm_write(value: Int) `{ pwmWrite(self->id, value); `}
# This function returns the value read at the given pin.
# It will be HIGH or LOW (true or false) depending on the logic level at the pin.
- fun read: Bool `{ return digitalRead(recv->id) == HIGH? true: false; `}
+ fun read: Bool `{ return digitalRead(self->id) == HIGH? true: false; `}
end
# RPI Pin modes
redef fun on_save_state
do
- app.data_store["context"] = context.to_json
+ app.data_store["context"] = context
super
end
do
super
- var save = app.data_store["context"]
- if save == null then return
- assert save isa String
+ var context = app.data_store["context"]
+ if not context isa CalculatorContext then return
- self.context = new CalculatorContext.from_json(save)
+ self.context = context
display.text = context.display_text
end
end
# Business logic of a calculator
module calculator_logic
-import json::dynamic
+import serialization
# Hold the state of the calculator and its services
class CalculatorContext
+ auto_serializable
+
# Result of the last operation
var result: nullable Numeric = null
self.result = result
self.current = null
end
-
- # Serialize calculator state to Json
- fun to_json: String
- do
- # Do not save NaN nor inf
- var result = self.result
- if result != null and (result.to_f.is_nan or result.to_f.is_inf != 0) then result = null
-
- var self_last_op = self.last_op
- var last_op
- if self_last_op == null then
- last_op = "null"
- else last_op = "\"{self_last_op}\""
-
- var self_current = self.current
- var current
- if self_current == null then
- current = "null"
- else current = "\"{self_current}\""
-
- return """
-{
- "result": {{{result or else "null"}}},
- "last_op": {{{last_op}}},
- "current": {{{current}}}
-}"""
- end
-
- # Load calculator state from Json
- init from_json(json_string: String)
- do
- var json = json_string.to_json_value
- if json.is_error then
- print "Loading state failed: {json.to_error}"
- return
- end
-
- var result = json["result"]
- if result.is_numeric then self.result = result.to_numeric
-
- var last_op = json["last_op"]
- if last_op.is_string then self.last_op = last_op.to_s.chars.first
-
- var current = json["current"]
- if current.is_string then self.current = new FlatBuffer.from(current.to_s)
- end
end
redef universal Float
# See the License for the specific language governing permissions and
# limitations under the License.
-# This sample has been implemented to show you how simple is it to play
-# with native callbacks (C) through an high level with NIT program.
-
+# This sample has been implemented to show you how simple is it to relay
+# native callbacks from C to a Nit program.
module callback_chimpanze
+
import callback_monkey
class Chimpanze
do
var monkey = new Monkey
print "Hum, I'm sleeping ..."
- # Invoking method which will take some time to compute, and
- # will be back in wokeUp method with information.
+
+ # Invoking method which will take some time to compute, and
+ # will be back in woke_up method with information.
# - Callback method defined in MonkeyActionCallable Interface
- monkey.wokeUpAction(self, "Hey, I'm awake.")
+ monkey.woke_up_action(self, "Hey, I'm awake.")
end
# Inherit callback method, defined by MonkeyActionCallable interface
- # - Back of wokeUpAction method
- redef fun wokeUp( sender:Monkey, message:Object )
+ # - Back of woke_up_action method
+ redef fun woke_up(sender:Monkey, message:Object)
do
print message
end
# See the License for the specific language governing permissions and
# limitations under the License.
-# This sample has been implemented to show you how simple is it to play
-# with native callbacks (C) through an high level with NIT program.
-
+# This sample has been implemented to show you how simple is it to relay
+# native callbacks from C to a Nit program.
module callback_monkey
in "C header" `{
#include <stdio.h>
#include <stdlib.h>
- typedef struct {
+ typedef struct {
int id;
int age;
} CMonkey;
void cbMonkey(CMonkey *mkey, void callbackFunc(CMonkey*, MonkeyAction*), MonkeyAction *data)
{
sleep(2);
- callbackFunc( mkey, data );
+ callbackFunc(mkey, data);
}
// Back of background treatment, will be redirected to callback function
- void nit_monkey_callback_func( CMonkey *mkey, MonkeyAction *data )
+ void nit_monkey_callback_func(CMonkey *mkey, MonkeyAction *data)
{
- // To call a your method, the signature must be written like this :
+ // To call a your method, the signature must be written like this:
// <Interface Name>_<Method>...
- MonkeyActionCallable_wokeUp( data->toCall, mkey, data->message );
+ MonkeyActionCallable_woke_up(data->toCall, mkey, data->message);
}
`}
# Implementable interface to get callback in defined methods
interface MonkeyActionCallable
- fun wokeUp( sender:Monkey, message: Object) is abstract
+ fun woke_up(sender:Monkey, message: Object) is abstract
end
# Defining my object type Monkey, which is, in a low level, a pointer to a C struct (CMonkey)
extern class Monkey `{ CMonkey * `}
-
+
new `{
- CMonkey *monkey = malloc( sizeof(CMonkey) );
+ CMonkey *monkey = malloc(sizeof(CMonkey));
monkey->age = 10;
monkey->id = 1;
return monkey;
`}
-
- # Object method which will get a callback in wokeUp method, defined in MonkeyActionCallable interface
+
+ # Object method which will get a callback in woke_up method, defined in MonkeyActionCallable interface
# Must be defined as Nit/C method because of C call inside
- fun wokeUpAction( toCall: MonkeyActionCallable, message: Object ) is extern import MonkeyActionCallable.wokeUp `{
+ fun woke_up_action(toCall: MonkeyActionCallable, message: Object) is extern import MonkeyActionCallable.woke_up `{
- // Allocating memory to keep reference of received parameters :
+ // Allocating memory to keep reference of received parameters:
// - Object receiver
- // - Message
- MonkeyAction *data = malloc( sizeof(MonkeyAction) );
+ // - Message
+ MonkeyAction *data = malloc(sizeof(MonkeyAction));
// Incrementing reference counter to prevent from releasing
- MonkeyActionCallable_incr_ref( toCall );
- Object_incr_ref( message );
-
+ MonkeyActionCallable_incr_ref(toCall);
+ Object_incr_ref(message);
+
data->toCall = toCall;
data->message = message;
-
- // Calling method which reproduce a callback by passing :
+
+ // Calling method which reproduce a callback by passing:
// - Receiver
// - Function pointer to object return method
// - Datas
- cbMonkey( recv, &nit_monkey_callback_func, data );
+ cbMonkey(self, &nit_monkey_callback_func, data);
`}
end
redef enum Int
fun n_chars: Int `{
int c;
- if ( abs(recv) >= 10 )
- c = 1+(int)log10f( (float)abs(recv) );
+ if ( abs(self) >= 10 )
+ c = 1+(int)log10f( (float)abs(self) );
else
c = 1;
- if ( recv < 0 ) c ++;
+ if ( self < 0 ) c ++;
return c;
`}
end
redef enum Int
# Returns self'th fibonnaci number
# implemented here in C for optimization purposes
- fun fib : Int import fib `{
- if ( recv < 2 )
- return recv;
+ fun fib: Int import fib `{
+ if (self < 2)
+ return self;
else
- return Int_fib( recv-1 ) + Int_fib( recv-2 );
+ return Int_fib(self-1) + Int_fib(self-2);
`}
# System call to sleep for "self" seconds
fun sleep `{
- sleep( recv );
+ sleep(self);
`}
- # Return atan2l( self, x ) from libmath
- fun atan_with( x : Int ) : Float `{
- return atan2( recv, x );
+ # Return atan2l(self, x) from libmath
+ fun atan_with(x: Int): Float `{
+ return atan2(self, x);
`}
# This method callback to Nit methods from C code
# * to_s, a method of all objects
# * String.to_cstring, a method of String to return an equivalent char*
fun foo import fib, +, to_s, String.to_cstring `{
- long recv_fib = Int_fib( recv );
- long recv_plus_fib = Int__plus( recv, recv_fib );
+ long self_fib = Int_fib(self);
+ long self_plus_fib = Int__plus(self, self_fib);
- String nit_string = Int_to_s( recv_plus_fib );
- char *c_string = String_to_cstring( nit_string );
+ String nit_string = Int_to_s(self_plus_fib);
+ char *c_string = String_to_cstring(nit_string);
- printf( "from C: self + fib(self) = %s\n", c_string );
+ printf("from C: self + fib(self) = %s\n", c_string);
`}
# Equivalent to foo but written in pure Nit
print "sleeping 1 second..."
1.sleep
-print 100.atan_with( 200 )
+print 100.atan_with(200)
8.foo
8.bar
android.util.Log.d("mnit_simple", "Java within NIT!!!");
// - Context needed from now on
- final android.app.Activity context = App_native_activity(recv);
+ final android.app.Activity context = App_native_activity(self);
// Vibration
android.os.Vibrator v = (android.os.Vibrator)
5. Set up the Chrome browser :
- PNaCl is enabled by default in Chrome version 31 and later.
- - For a better development experience, it’s also recommended to disable the Chrome cache :
- - Open Chrome’s developer tools by clicking the menu icon menu-icon and choosing Tools > Developer tools.
+ - For a better development experience, it’s also recommended to disable the Chrome cache :
+ - Open Chrome’s developer tools by clicking the menu icon menu-icon and choosing Tools > Developer tools.
- Click the gear icon gear-icon in the bottom right corner of the Chrome window.
- Under the “General” settings, check the box next to “Disable cache (while DevTools is open)”.
- Keep the Developer Tools pane open while developing Native Client applications.
# ~~~
module a_star
+import serialization
+
# General graph node
class Node
+ super Serializable
+
# Type of the others nodes in the `graph`
type N: Node
end
end
end
+
+ # We customize the serialization process to avoid problems with recursive
+ # serialization engines. These engines, such as `JsonSerializer`,
+ # are at danger to serialize the graph as a very deep tree.
+ # With a large graph it can cause a stack overflow.
+ #
+ # Instead, we serialize the nodes first and then the links.
+ redef fun core_serialize_to(serializer: Serializer)
+ do
+ serializer.serialize_attribute("graph", graph)
+ end
+
+ redef init from_deserializer(deserializer)
+ do
+ deserializer.notify_of_creation self
+
+ var graph = deserializer.deserialize_attribute("graph")
+ assert graph isa Graph[N, Link]
+ self.graph = graph
+ end
end
# Link between two nodes and associated to a graph
class Link
+ auto_serializable
+
# Type of the nodes in `graph`
type N: Node
# General graph
class Graph[N: Node, L: Link]
+ super Serializable
+
# Nodes in this graph
var nodes: Set[N] = new HashSet[N]
# Used to check if nodes have been searched in one pathfinding
private var pathfinding_current_evocation: Int = 0
+
+ redef fun core_serialize_to(serializer: Serializer)
+ do
+ serializer.serialize_attribute("nodes", nodes)
+ serializer.serialize_attribute("links", links)
+ end
+
+ redef init from_deserializer(deserializer)
+ do
+ deserializer.notify_of_creation self
+
+ var nodes = deserializer.deserialize_attribute("nodes")
+ assert nodes isa HashSet[N]
+ self.nodes = nodes
+
+ var links = deserializer.deserialize_attribute("links")
+ assert links isa HashSet[L]
+ for link in links do add_link link
+ end
end
# Result from path finding and a walkable path
class AStarPath[N]
+ auto_serializable
- # The total cost of this path
+ # Total cost of this path
var total_cost: Int
- # The list of nodes composing this path
+ # Nodes composing this path
var nodes = new List[N]
private var at: Int = 0
# Context related to an evocation of pathfinding
class PathContext
+ auto_serializable
+
# Type of the nodes in `graph`
type N: Node
# Warning: A* is not optimize for such a case
class ConstantPathContext
super PathContext
+ auto_serializable
redef fun worst_cost do return 1
redef fun cost(l) do return 1
# A `PathContext` for graphs with `WeightedLink`
class WeightedPathContext
super PathContext
+ auto_serializable
redef type L: WeightedLink
# A `Link` with a `weight`
class WeightedLink
super Link
+ auto_serializable
# The `weight`, or cost, of this link
var weight: Int
# Advanced path conditions with customizable accept states
class TargetCondition[N: Node]
+ auto_serializable
+
# Should the pathfinding accept `node` as a goal?
fun accept(node: N): Bool is abstract
# HACK for bug #845
redef fun new_global_ref: SELF import sys, Sys.jni_env `{
- Sys sys = NativeActivity_sys(recv);
+ Sys sys = NativeActivity_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
extern class NativeAssetManager in "Java" `{ android.content.res.AssetManager `}
super JavaObject
- fun close in "Java" `{ recv.close(); `}
+ fun close in "Java" `{ self.close(); `}
fun get_locales: Array[JavaString] import Array[JavaString], Array[JavaString].add in "Java" `{
int arr = new_Array_of_JavaString();
- for (String s : recv.getLocales()) {
+ for (String s : self.getLocales()) {
Array_of_JavaString_add(arr, s);
}
return arr;
fun list(path: JavaString): Array[JavaString] import Array[JavaString], Array[JavaString].add in "Java" `{
int arr = new_Array_of_JavaString();
try {
- for (String s : recv.list(path)) {
+ for (String s : self.list(path)) {
Array_of_JavaString_add(arr, s);
}
}catch (IOException e) {
fun open(file_name: JavaString): NativeInputStream in "Java" `{
InputStream stream = null;
try {
- stream = recv.open(file_name);
+ stream = self.open(file_name);
}catch (IOException e) {
Log.e("Error while opening " + file_name, e.getMessage());
e.printStackTrace();
fun open_fd(file_name: JavaString): NativeAssetFileDescriptor in "Java" `{
AssetFileDescriptor afd = null;
try {
- afd = recv.openFd(file_name);
+ afd = self.openFd(file_name);
}catch(IOException e){
Log.e("Error while opening " + file_name, e.getMessage());
e.printStackTrace();
fun open_non_asset_fd(file_name: JavaString): NativeAssetFileDescriptor in "Java" `{
AssetFileDescriptor afd = null;
try {
- afd = recv.openNonAssetFd(file_name);
+ afd = self.openNonAssetFd(file_name);
}catch(IOException e){
Log.e("Error while opening " + file_name, e.getMessage());
e.printStackTrace();
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeResources_sys(recv);
+ Sys sys = NativeResources_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
extern class NativeResources in "Java" `{ android.content.res.Resources `}
super JavaObject
- fun get_assets:NativeAssetManager in "Java" `{ return recv.getAssets(); `}
- fun get_color(id: Int): Int in "Java" `{ return recv.getColor((int)id); `}
- fun get_boolean(id: Int): Bool in "Java" `{ return recv.getBoolean((int)id); `}
- fun get_dimension(id: Int): Int in "Java" `{ return (int)recv.getDimension((int)id); `}
- fun get_drawable(id: Int): NativeDrawable in "Java" `{ return recv.getDrawable((int)id); `}
- fun get_identifier(name, def_type, def_package: JavaString): Int in "Java" `{ return recv.getIdentifier(name, def_type, def_package); `}
- fun get_integer(id: Int): Int in "Java" `{ return recv.getInteger((int)id); `}
- fun get_string(id: Int): JavaString in "Java" `{ return recv.getString((int)id); `}
- fun get_resource_entry_name(resid: Int): JavaString in "Java" `{ return recv.getResourceEntryName((int)resid); `}
- fun get_resource_name(resid: Int): JavaString in "Java" `{ return recv.getResourceName((int)resid); `}
- fun get_resource_pakage_name(resid: Int): JavaString in "Java" `{ return recv.getResourcePackageName((int)resid); `}
- fun get_resource_type_name(resid: Int): JavaString in "Java" `{ return recv.getResourceTypeName((int)resid); `}
+ fun get_assets:NativeAssetManager in "Java" `{ return self.getAssets(); `}
+ fun get_color(id: Int): Int in "Java" `{ return self.getColor((int)id); `}
+ fun get_boolean(id: Int): Bool in "Java" `{ return self.getBoolean((int)id); `}
+ fun get_dimension(id: Int): Int in "Java" `{ return (int)self.getDimension((int)id); `}
+ fun get_drawable(id: Int): NativeDrawable in "Java" `{ return self.getDrawable((int)id); `}
+ fun get_identifier(name, def_type, def_package: JavaString): Int in "Java" `{ return self.getIdentifier(name, def_type, def_package); `}
+ fun get_integer(id: Int): Int in "Java" `{ return self.getInteger((int)id); `}
+ fun get_string(id: Int): JavaString in "Java" `{ return self.getString((int)id); `}
+ fun get_resource_entry_name(resid: Int): JavaString in "Java" `{ return self.getResourceEntryName((int)resid); `}
+ fun get_resource_name(resid: Int): JavaString in "Java" `{ return self.getResourceName((int)resid); `}
+ fun get_resource_pakage_name(resid: Int): JavaString in "Java" `{ return self.getResourcePackageName((int)resid); `}
+ fun get_resource_type_name(resid: Int): JavaString in "Java" `{ return self.getResourceTypeName((int)resid); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeResources_sys(recv);
+ Sys sys = NativeResources_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
# Create a NativeBitmap using a resource ID and the NativeResources
# Called by the ResourceManager
new from_resources(res: NativeResources, id: Int) in "Java" `{ return BitmapFactory.decodeResource(res, (int)id); `}
- fun width: Int in "Java" `{ return recv.getWidth(); `}
- fun height: Int in "Java" `{ return recv.getHeight(); `}
+ fun width: Int in "Java" `{ return self.getWidth(); `}
+ fun height: Int in "Java" `{ return self.getHeight(); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeResources_sys(recv);
+ Sys sys = NativeResources_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
fun close in "Java" `{
try {
- recv.close();
+ self.close();
}catch(IOException e){
e.printStackTrace();
}
`}
fun create_input_stream: NativeFileInputStream in "Java" `{
try {
- return recv.createInputStream();
+ return self.createInputStream();
}catch(IOException e){
Log.e("Error creating input_stream", e.getMessage());
e.printStackTrace();
`}
fun create_output_stream: NativeFileOutputStream in "Java" `{
try {
- return recv.createOutputStream();
+ return self.createOutputStream();
}catch(IOException e){
Log.e("Error creating output stream", e.getMessage());
e.printStackTrace();
return null;
}
`}
- fun describe_contents: Int in "Java" `{ return (int)recv.describeContents(); `}
- fun declared_length: Int in "Java" `{ return (int)recv.getDeclaredLength(); `}
- # fun extras: Bundle in "Java" `{ return recv.getExtras(); `}
+ fun describe_contents: Int in "Java" `{ return (int)self.describeContents(); `}
+ fun declared_length: Int in "Java" `{ return (int)self.getDeclaredLength(); `}
+ # fun extras: Bundle in "Java" `{ return self.getExtras(); `}
fun file_descriptor: NativeFileDescriptor in "Java" `{
- FileDescriptor fd = recv.getFileDescriptor();
+ FileDescriptor fd = self.getFileDescriptor();
if (fd == null) {
Log.e("AssetFileDesciptorError", "Can't retrieve the FileDescriptor of this AssetFileDescriptor");
}
return fd;
`}
- fun length: Int in "Java" `{ return (int)recv.getLength(); `}
- fun start_offset: Int in "Java" `{ return (int)recv.getStartOffset(); `}
- redef fun to_s: String import JavaString.to_s in "Java" `{ return JavaString_to_s(recv.toString()); `}
+ fun length: Int in "Java" `{ return (int)self.getLength(); `}
+ fun start_offset: Int in "Java" `{ return (int)self.getStartOffset(); `}
+ redef fun to_s: String import JavaString.to_s in "Java" `{ return JavaString_to_s(self.toString()); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeResources_sys(recv);
+ Sys sys = NativeResources_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
var asset_manager: AssetManager is lazy do return new AssetManager(self)
# Get the native AssetsManager of the application, used to initialize the nit's AssetManager
- private fun assets: NativeAssetManager import native_activity in "Java" `{ return App_native_activity(recv).getAssets(); `}
+ private fun assets: NativeAssetManager import native_activity in "Java" `{ return App_native_activity(self).getAssets(); `}
# Get the package name of the application
- private fun package_name: JavaString import native_activity in "Java" `{ return App_native_activity(recv).getPackageName(); `}
+ private fun package_name: JavaString import native_activity in "Java" `{ return App_native_activity(self).getPackageName(); `}
# Get the native ResourceManager of the application, used to initialize the nit's ResourceManager
- private fun resources: NativeResources import native_activity in "Java" `{ return App_native_activity(recv).getResources(); `}
+ private fun resources: NativeResources import native_activity in "Java" `{ return App_native_activity(self).getResources(); `}
end
# Current audio mode.
# ( MODE_NORMAL = 0, MODE_RINGTONE = 1, MODE_IN_CALL = 2 or MODE_IN_COMMUNICATION = 3 )
- fun mode: Int in "Java" `{ return recv.getMode(); `}
+ fun mode: Int in "Java" `{ return self.getMode(); `}
# Sets the audio mode.
# ( MODE_NORMAL = 0, MODE_RINGTONE = 1, MODE_IN_CALL = 2 or MODE_IN_COMMUNICATION = 3 )
- fun mode=(i: Int) in "Java" `{ recv.setMode((int)i); `}
+ fun mode=(i: Int) in "Java" `{ self.setMode((int)i); `}
# Sends a request to obtain audio focus
fun request_audio_focus: Int in "Java" `{
- return recv.requestAudioFocus(afChangeListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
+ return self.requestAudioFocus(afChangeListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
`}
# Gives up audio focus
- fun abandon_audio_focus: Int in "Java" `{ return recv.abandonAudioFocus(afChangeListener); `}
+ fun abandon_audio_focus: Int in "Java" `{ return self.abandonAudioFocus(afChangeListener); `}
end
# Media Player from Java, used to play long sounds or musics, not simultaneously
mp.setAudioStreamType(AudioManager.STREAM_MUSIC);
return mp;
`}
- fun start in "Java" `{ recv.start(); `}
+ fun start in "Java" `{ self.start(); `}
fun prepare in "Java" `{
try {
- recv.prepare();
+ self.prepare();
}catch(IOException e) {
Log.e("Error preparing the Media Player", e.getMessage());
e.printStackTrace();
}
`}
- fun create(context: NativeActivity, id: Int): NativeMediaPlayer in "Java" `{ return recv.create(context, (int)id); `}
- fun pause in "Java" `{ recv.pause(); `}
- fun stop in "Java" `{ recv.stop(); `}
- fun playing: Bool in "Java" `{ return recv.isPlaying(); `}
- fun release in "Java" `{ recv.release(); `}
- fun duration: Int in "Java" `{ return recv.getDuration(); `}
- fun looping: Bool in "Java" `{ return recv.isLooping(); `}
- fun looping=(b: Bool) in "Java" `{ recv.setLooping(b); `}
- fun volume=(vol: Float) in "Java" `{ recv.setVolume((float)vol, (float)vol); `}
- fun both_volume(left_volume, right_volume: Float) in "Java" `{ recv.setVolume((float)left_volume, (float)right_volume); `}
- fun stream_type=(stream_type: Int) in "Java" `{ recv.setAudioStreamType((int)stream_type); `}
+ fun create(context: NativeActivity, id: Int): NativeMediaPlayer in "Java" `{ return self.create(context, (int)id); `}
+ fun pause in "Java" `{ self.pause(); `}
+ fun stop in "Java" `{ self.stop(); `}
+ fun playing: Bool in "Java" `{ return self.isPlaying(); `}
+ fun release in "Java" `{ self.release(); `}
+ fun duration: Int in "Java" `{ return self.getDuration(); `}
+ fun looping: Bool in "Java" `{ return self.isLooping(); `}
+ fun looping=(b: Bool) in "Java" `{ self.setLooping(b); `}
+ fun volume=(vol: Float) in "Java" `{ self.setVolume((float)vol, (float)vol); `}
+ fun both_volume(left_volume, right_volume: Float) in "Java" `{ self.setVolume((float)left_volume, (float)right_volume); `}
+ fun stream_type=(stream_type: Int) in "Java" `{ self.setAudioStreamType((int)stream_type); `}
fun data_source_fd(fd: NativeFileDescriptor, start_offset, length: Int) in "Java" `{
try {
- recv.setDataSource(fd, start_offset, length);
+ self.setDataSource(fd, start_offset, length);
}catch(IOException e) {
Log.e("Error loading the Media Player with a file descriptor", e.getMessage());
e.printStackTrace();
`}
fun data_source_path(path: JavaString) in "Java" `{
try {
- recv.setDataSource(path);
+ self.setDataSource(path);
}catch(IOException e) {
Log.e("Error loading the Media Player", e.getMessage());
e.printStackTrace();
}
`}
- fun reset in "Java" `{ recv.reset(); `}
+ fun reset in "Java" `{ self.reset(); `}
end
# Sound Pool from Java, used to play sounds simultaneously
new(max_streams, stream_type, src_quality: Int) in "Java" `{
return new SoundPool((int)max_streams, (int)stream_type, (int)src_quality);
`}
- fun load_asset_fd(afd: NativeAssetFileDescriptor, priority: Int): Int in "Java" `{ return recv.load(afd, (int)priority); `}
- fun load_id(context: NativeActivity, resid, priority: Int): Int in "Java" `{ return recv.load(context, (int)resid, (int)priority); `}
- fun load_path(path: JavaString, priority: Int): Int in "Java" `{ return recv.load(path, (int)priority); `}
+ fun load_asset_fd(afd: NativeAssetFileDescriptor, priority: Int): Int in "Java" `{ return self.load(afd, (int)priority); `}
+ fun load_id(context: NativeActivity, resid, priority: Int): Int in "Java" `{ return self.load(context, (int)resid, (int)priority); `}
+ fun load_path(path: JavaString, priority: Int): Int in "Java" `{ return self.load(path, (int)priority); `}
fun play(sound_id: Int, left_volume, right_volume: Float, priority, l: Int, rate: Float): Int in "Java" `{
- return recv.play((int)sound_id, (float)left_volume, (float)right_volume, (int)priority, (int)l, (float)rate);
+ return self.play((int)sound_id, (float)left_volume, (float)right_volume, (int)priority, (int)l, (float)rate);
`}
- fun pause(stream_id: Int) in "Java" `{ recv.pause((int)stream_id); `}
- fun auto_pause in "Java" `{ recv.autoPause(); `}
- fun auto_resume in "Java" `{ recv.autoResume(); `}
- fun resume(stream_id: Int) in "Java" `{ recv.resume((int)stream_id); `}
- fun set_loop(stream_id, l: Int) in "Java" `{ recv.setLoop((int)stream_id, (int)l); `}
- fun set_priority(stream_id, priority: Int) in "Java" `{ recv.setPriority((int)stream_id, (int)priority); `}
- fun set_rate(stream_id: Int, rate: Float) in "Java" `{ recv.setRate((int)stream_id, (float)rate); `}
- fun set_volume(stream_id: Int, left_volume, right_volume: Float) in "Java" `{ recv.setVolume((int)stream_id, (float)left_volume, (float)right_volume); `}
- fun stop(stream_id: Int) in "Java" `{ recv.stop((int)stream_id); `}
- fun unload(sound_id: Int): Bool in "Java" `{ return recv.unload((int)sound_id); `}
- fun release in "Java" `{ recv.release(); `}
+ fun pause(stream_id: Int) in "Java" `{ self.pause((int)stream_id); `}
+ fun auto_pause in "Java" `{ self.autoPause(); `}
+ fun auto_resume in "Java" `{ self.autoResume(); `}
+ fun resume(stream_id: Int) in "Java" `{ self.resume((int)stream_id); `}
+ fun set_loop(stream_id, l: Int) in "Java" `{ self.setLoop((int)stream_id, (int)l); `}
+ fun set_priority(stream_id, priority: Int) in "Java" `{ self.setPriority((int)stream_id, (int)priority); `}
+ fun set_rate(stream_id: Int, rate: Float) in "Java" `{ self.setRate((int)stream_id, (float)rate); `}
+ fun set_volume(stream_id: Int, left_volume, right_volume: Float) in "Java" `{ self.setVolume((int)stream_id, (float)left_volume, (float)right_volume); `}
+ fun stop(stream_id: Int) in "Java" `{ self.stop((int)stream_id); `}
+ fun unload(sound_id: Int): Bool in "Java" `{ return self.unload((int)sound_id); `}
+ fun release in "Java" `{ self.release(); `}
end
# Get the native audio manager
fun audio_manager: NativeAudioManager import native_activity in "Java" `{
- return (AudioManager)App_native_activity(recv).getSystemService(Context.AUDIO_SERVICE);
+ return (AudioManager)App_native_activity(self).getSystemService(Context.AUDIO_SERVICE);
`}
# Sets the stream of the app to STREAM_MUSIC.
# STREAM_MUSIC is the default stream used by android apps.
private fun manage_audio_stream import native_activity, native_app_glue in "Java" `{
- App_native_activity(recv).setVolumeControlStream(AudioManager.STREAM_MUSIC);
+ App_native_activity(self).setVolumeControlStream(AudioManager.STREAM_MUSIC);
`}
# Retrieves a sound with a soundpool in the `assets` folder using its name.
# See the License for the specific language governing permissions and
# limitations under the License.
-# A mapping class of `String` to various value types used by the
+# A mapping class of `String` to various value types used by the
# Android API for various data exchange purposes
module bundle
new in "Java" `{ return new Bundle(); `}
- fun clone: JavaObject in "Java" `{ return recv.clone(); `}
- fun size: Int in "Java" `{ return recv.size(); `}
- fun is_empty: Bool in "Java" `{ return recv.isEmpty(); `}
- fun clear in "Java" `{ recv.clear(); `}
- fun contains_key(key: JavaString): Bool in "Java" `{ return recv.containsKey(key); `}
- fun get(key: JavaString): JavaObject in "Java" `{ return recv.get(key); `}
- fun remove(key: JavaString) in "Java" `{ recv.remove(key); `}
- fun put_all(bundle: NativeBundle) in "Java" `{ recv.putAll(bundle); `}
+ fun clone: JavaObject in "Java" `{ return self.clone(); `}
+ fun size: Int in "Java" `{ return self.size(); `}
+ fun is_empty: Bool in "Java" `{ return self.isEmpty(); `}
+ fun clear in "Java" `{ self.clear(); `}
+ fun contains_key(key: JavaString): Bool in "Java" `{ return self.containsKey(key); `}
+ fun get(key: JavaString): JavaObject in "Java" `{ return self.get(key); `}
+ fun remove(key: JavaString) in "Java" `{ self.remove(key); `}
+ fun put_all(bundle: NativeBundle) in "Java" `{ self.putAll(bundle); `}
fun key_set: HashSet[JavaString] import HashSet[JavaString],
HashSet[JavaString].add in "Java" `{
- Set<String> java_set = recv.keySet();
+ Set<String> java_set = self.keySet();
int nit_hashset = new_HashSet_of_JavaString();
for (String element: java_set)
return nit_hashset;
`}
- fun has_file_descriptors: Bool in "Java" `{ return recv.hasFileDescriptors(); `}
- fun put_boolean(key: JavaString, value: Bool) in "Java" `{
- recv.putBoolean(key, value);
+ fun has_file_descriptors: Bool in "Java" `{ return self.hasFileDescriptors(); `}
+ fun put_boolean(key: JavaString, value: Bool) in "Java" `{
+ self.putBoolean(key, value);
`}
- fun put_byte(key: JavaString, value: Int) in "Java" `{
- recv.putByte(key, (byte) value);
+ fun put_byte(key: JavaString, value: Int) in "Java" `{
+ self.putByte(key, (byte) value);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
- fun put_char(key: JavaString, value: Char) in "Java" `{
- recv.putChar(key, value);
+ fun put_char(key: JavaString, value: Char) in "Java" `{
+ self.putChar(key, value);
`}
- fun put_short(key: JavaString, value: Int) in "Java" `{
- recv.putShort(key, (short) value);
+ fun put_short(key: JavaString, value: Int) in "Java" `{
+ self.putShort(key, (short) value);
`}
- fun put_int(key: JavaString, value: Int) in "Java" `{
- recv.putInt(key, (int) value);
+ fun put_int(key: JavaString, value: Int) in "Java" `{
+ self.putInt(key, (int) value);
`}
- fun put_long(key: JavaString, value: Int) in "Java" `{
- recv.putLong(key, value);
+ fun put_long(key: JavaString, value: Int) in "Java" `{
+ self.putLong(key, value);
`}
- fun put_float(key: JavaString, value: Float) in "Java" `{
- recv.putFloat(key, (float) value);
+ fun put_float(key: JavaString, value: Float) in "Java" `{
+ self.putFloat(key, (float) value);
`}
- fun put_double(key: JavaString, value: Float) in "Java" `{
- recv.putDouble(key, value);
+ fun put_double(key: JavaString, value: Float) in "Java" `{
+ self.putDouble(key, value);
`}
- fun put_string(key: JavaString, value: JavaString) in "Java" `{
- recv.putString(key, value);
+ fun put_string(key: JavaString, value: JavaString) in "Java" `{
+ self.putString(key, value);
`}
- fun put_char_sequence(key: JavaString, value: JavaString) in "Java" `{
- recv.putCharSequence(key, value);
+ fun put_char_sequence(key: JavaString, value: JavaString) in "Java" `{
+ self.putCharSequence(key, value);
`}
- fun put_integer_array_list(key: JavaString, value: Array[Int])
+ fun put_integer_array_list(key: JavaString, value: Array[Int])
import Array[Int].length, Array[Int].[] in "Java" `{
- ArrayList<Integer> java_array =
+ ArrayList<Integer> java_array =
new ArrayList<Integer>((int) Array_of_Int_length(value));
-
+
for(int i=0; i < java_array.size(); ++i)
java_array.add((int) Array_of_Int__index(value, i));
- recv.putIntegerArrayList(key, java_array);
+ self.putIntegerArrayList(key, java_array);
`}
fun put_string_array_list(key: JavaString, value: Array[JavaString])
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
ArrayList<String> java_array = new ArrayList<String>((int)Array_of_JavaString_length(value));
-
+
for(int i=0; i < java_array.size(); ++i)
java_array.add(Array_of_JavaString__index(value, i));
- recv.putStringArrayList(key, java_array);
+ self.putStringArrayList(key, java_array);
`}
fun put_char_sequence_array_list(key: JavaString, value: Array[JavaString])
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
- ArrayList<CharSequence> java_array =
+ ArrayList<CharSequence> java_array =
new ArrayList<CharSequence>((int)Array_of_JavaString_length(value));
-
+
for(int i=0; i < java_array.size(); ++i)
java_array.add(Array_of_JavaString__index(value, i));
- recv.putCharSequenceArrayList(key, java_array);
+ self.putCharSequenceArrayList(key, java_array);
`}
fun put_boolean_array(key: JavaString, value: Array[Bool])
import Array[Bool].length, Array[Bool].[] in "Java" `{
boolean[] java_array = new boolean[(int)Array_of_Bool_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Bool__index(value, i);
- recv.putBooleanArray(key, java_array);
+ self.putBooleanArray(key, java_array);
`}
fun put_byte_array(key: JavaString, value: Array[Int])
import Array[Int].length, Array[Int].[] in "Java" `{
byte[] java_array = new byte[(int)Array_of_Int_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = (byte) Array_of_Int__index(value, i);
- recv.putByteArray(key, java_array);
+ self.putByteArray(key, java_array);
`}
fun put_short_array(key: JavaString, value: Array[Int])
import Array[Int].length, Array[Int].[] in "Java" `{
short[] java_array = new short[(int)Array_of_Int_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = (short) Array_of_Int__index(value, i);
- recv.putShortArray(key, java_array);
+ self.putShortArray(key, java_array);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun put_char_array(key: JavaString, value: Array[Char])
import Array[Char].length, Array[Char].[] in "Java" `{
char[] java_array = new char[(int)Array_of_Char_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Char__index(value, i);
- recv.putCharArray(key, java_array);
+ self.putCharArray(key, java_array);
`}
fun put_int_array(key: JavaString, value: Array[Int])
import Array[Int].length, Array[Int].[] in "Java" `{
int[] java_array = new int[(int)Array_of_Int_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = (int) Array_of_Int__index(value, i);
- recv.putIntArray(key, java_array);
+ self.putIntArray(key, java_array);
`}
fun put_long_array(key: JavaString, value: Array[Int])
import Array[Int].length, Array[Int].[] in "Java" `{
long[] java_array = new long[(int)Array_of_Int_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Int__index(value, i);
- recv.putLongArray(key, java_array);
+ self.putLongArray(key, java_array);
`}
fun put_float_array(key: JavaString, value: Array[Float])
import Array[Float].length, Array[Float].[] in "Java" `{
float[] java_array = new float[(int)Array_of_Float_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = (float) Array_of_Float__index(value, i);
- recv.putFloatArray(key, java_array);
+ self.putFloatArray(key, java_array);
`}
fun put_double_array(key: JavaString, value: Array[Float])
import Array[Float].length, Array[Float].[] in "Java" `{
double[] java_array = new double[(int)Array_of_Float_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Float__index(value, i);
- recv.putDoubleArray(key, java_array);
+ self.putDoubleArray(key, java_array);
`}
fun put_string_array(key: JavaString, value: Array[JavaString])
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
String[] java_array = new String[(int)Array_of_JavaString_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_JavaString__index(value, i);
- recv.putStringArray(key, java_array);
+ self.putStringArray(key, java_array);
`}
fun put_char_sequence_array(key: JavaString, value: Array[JavaString])
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
CharSequence[] java_array = new CharSequence[(int)Array_of_JavaString_length(value)];
-
+
for(int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_JavaString__index(value, i);
- recv.putCharSequenceArray(key, java_array);
+ self.putCharSequenceArray(key, java_array);
`}
- fun put_bundle(key: JavaString, value: NativeBundle) in "Java" `{
- recv.putBundle(key, value);
+ fun put_bundle(key: JavaString, value: NativeBundle) in "Java" `{
+ self.putBundle(key, value);
`}
- fun get_boolean(key: JavaString): Bool in "Java" `{ return recv.getBoolean(key); `}
+ fun get_boolean(key: JavaString): Bool in "Java" `{ return self.getBoolean(key); `}
fun get_boolean_with_def_value(key: JavaString, def_value: Bool): Bool in "Java" `{
- return recv.getBoolean(key, def_value);
+ return self.getBoolean(key, def_value);
`}
- fun get_byte(key: JavaString): Int in "Java" `{ return recv.getByte(key); `}
- fun get_byte_with_def_value(key: JavaString, def_value: Int): Int in "Java" `{
- return recv.getByte(key, (byte) def_value);
+ fun get_byte(key: JavaString): Int in "Java" `{ return self.getByte(key); `}
+ fun get_byte_with_def_value(key: JavaString, def_value: Int): Int in "Java" `{
+ return self.getByte(key, (byte) def_value);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
- fun get_char(key: JavaString): Char in "Java" `{ return recv.getChar(key); `}
+ fun get_char(key: JavaString): Char in "Java" `{ return self.getChar(key); `}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun get_char_with_def_value(key: JavaString, def_value: Char): Char in "Java" `{
- return recv.getChar(key, def_value);
+ return self.getChar(key, def_value);
`}
- fun get_short(key: JavaString): Int in "Java" `{ return (short) recv.getShort(key); `}
+ fun get_short(key: JavaString): Int in "Java" `{ return (short) self.getShort(key); `}
fun get_short_with_def_value(key: JavaString, def_value: Int): Int in "Java" `{
- return (short) recv.getShort(key, (short) def_value);
+ return (short) self.getShort(key, (short) def_value);
`}
- fun get_int(key: JavaString): Int in "Java" `{ return recv.getInt(key); `}
+ fun get_int(key: JavaString): Int in "Java" `{ return self.getInt(key); `}
fun get_int_with_def_value(key: JavaString, def_value: Int): Int in "Java" `{
- return recv.getInt(key, (int) def_value);
+ return self.getInt(key, (int) def_value);
`}
- fun get_long(key: JavaString): Int in "Java" `{ return recv.getLong(key); `}
+ fun get_long(key: JavaString): Int in "Java" `{ return self.getLong(key); `}
fun get_long_with_def_value(key: JavaString, def_value: Int): Int in "Java" `{
- return recv.getLong(key);
+ return self.getLong(key);
`}
fun get_float(key: JavaString): Float in "Java" `{
- return (float) recv.getFloat(key);
+ return (float) self.getFloat(key);
`}
fun get_float_with_def_value(key: JavaString, def_value: Float): Float in "Java" `{
- return (float) recv.getFloat(key, (float) def_value);
+ return (float) self.getFloat(key, (float) def_value);
`}
- fun get_double(key: JavaString): Float in "Java" `{ return recv.getDouble(key); `}
- fun get_double_with_def_value(key: JavaString, def_value: Float): Float in "Java" `{
- return recv.getDouble(key, def_value);
+ fun get_double(key: JavaString): Float in "Java" `{ return self.getDouble(key); `}
+ fun get_double_with_def_value(key: JavaString, def_value: Float): Float in "Java" `{
+ return self.getDouble(key, def_value);
`}
fun get_string(key: JavaString): JavaString in "Java" `{
- return recv.getString(key);
+ return self.getString(key);
`}
fun get_char_sequence(key: JavaString): JavaString in "Java" `{
- return (String) recv.getCharSequence(key);
+ return (String) self.getCharSequence(key);
`}
fun get_bundle(key: JavaString): NativeBundle in "Java" `{
- return recv.getBundle(key);
+ return self.getBundle(key);
`}
fun get_integer_array_list(key: JavaString): Array[Int]
import Array[Int], Array[Int].add in "Java" `{
- ArrayList<Integer> java_array = recv.getIntegerArrayList(key);
+ ArrayList<Integer> java_array = self.getIntegerArrayList(key);
int nit_array = new_Array_of_Int();
if (java_array == null) return nit_array;
`}
fun get_string_array_list(key: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- ArrayList<String> java_array = recv.getStringArrayList(key);
+ ArrayList<String> java_array = self.getStringArrayList(key);
int nit_array = new_StringCopyArray();
if (java_array == null) return nit_array;
`}
fun get_char_sequence_array_list(key: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- ArrayList<CharSequence> java_array = recv.getCharSequenceArrayList(key);
+ ArrayList<CharSequence> java_array = self.getCharSequenceArrayList(key);
int nit_array = new_StringCopyArray();
if (java_array == null) return nit_array;
return StringCopyArray_collection(nit_array);
`}
fun get_boolean_array(key: JavaString): Array[Bool]
- import Array[Bool], Array[Bool].add in "Java" `{
- boolean[] java_array = recv.getBooleanArray(key);
+ import Array[Bool], Array[Bool].add in "Java" `{
+ boolean[] java_array = self.getBooleanArray(key);
int nit_array = new_Array_of_Bool();
if (java_array == null) return nit_array;
return nit_array;
`}
fun get_byte_array(key: JavaString): Array[Int]
- import Array[Int], Array[Int].add in "Java" `{
- byte[] java_array = recv.getByteArray(key);
+ import Array[Int], Array[Int].add in "Java" `{
+ byte[] java_array = self.getByteArray(key);
int nit_array = new_Array_of_Int();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Int_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
fun get_short_array(key: JavaString): Array[Int]
- import Array[Int], Array[Int].add in "Java" `{
- short[] java_array = recv.getShortArray(key);
+ import Array[Int], Array[Int].add in "Java" `{
+ short[] java_array = self.getShortArray(key);
int nit_array = new_Array_of_Int();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Int_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun get_char_array(key: JavaString): Array[Char]
- import Array[Char], Array[Char].add in "Java" `{
- char[] java_array = recv.getCharArray(key);
+ import Array[Char], Array[Char].add in "Java" `{
+ char[] java_array = self.getCharArray(key);
int nit_array = new_Array_of_Char();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Char_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
fun get_int_array(key: JavaString): Array[Int]
- import Array[Int], Array[Int].add in "Java" `{
- int[] java_array = recv.getIntArray(key);
+ import Array[Int], Array[Int].add in "Java" `{
+ int[] java_array = self.getIntArray(key);
int nit_array = new_Array_of_Int();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Int_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
# FIXME: Get rid of the int cast as soon as the ffi is fixed
fun get_long_array(key: JavaString): Array[Int]
- import Array[Int], Array[Int].add in "Java" `{
- long[] java_array = recv.getLongArray(key);
+ import Array[Int], Array[Int].add in "Java" `{
+ long[] java_array = self.getLongArray(key);
int nit_array = new_Array_of_Int();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Int_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
fun get_float_array(key: JavaString): Array[Float]
- import Array[Float], Array[Float].add in "Java" `{
- float[] java_array = recv.getFloatArray(key);
+ import Array[Float], Array[Float].add in "Java" `{
+ float[] java_array = self.getFloatArray(key);
int nit_array = new_Array_of_Float();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Float_add(nit_array, (double) java_array[i]);
-
+
return nit_array;
`}
fun get_double_array(key: JavaString): Array[Float]
- import Array[Float], Array[Float].add in "Java" `{
- double[] java_array = recv.getDoubleArray(key);
+ import Array[Float], Array[Float].add in "Java" `{
+ double[] java_array = self.getDoubleArray(key);
int nit_array = new_Array_of_Float();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
Array_of_Float_add(nit_array, java_array[i]);
-
+
return nit_array;
`}
fun get_string_array(key: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- String[] java_array = recv.getStringArray(key);
+ String[] java_array = self.getStringArray(key);
int nit_array = new_StringCopyArray();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
StringCopyArray_add(nit_array, java_array[i]);
-
+
return StringCopyArray_collection(nit_array);
`}
fun get_char_sequence_array(key: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- CharSequence[] java_array = recv.getCharSequenceArray(key);
+ CharSequence[] java_array = self.getCharSequenceArray(key);
int nit_array = new_StringCopyArray();
-
+
if (java_array == null) return nit_array;
for(int i=0; i < java_array.length; ++i)
StringCopyArray_add(nit_array, (String)java_array[i]);
-
+
return StringCopyArray_collection(nit_array);
`}
- fun describe_contents: Int in "Java" `{ return recv.describeContents(); `}
- fun to_string: JavaString in "Java" `{ return recv.toString(); `}
+ fun describe_contents: Int in "Java" `{ return self.describeContents(); `}
+ fun to_string: JavaString in "Java" `{ return self.toString(); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeBundle_sys(recv);
+ Sys sys = NativeBundle_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
sys.jni_env.pop_local_frame
return return_value
end
-
+
# Returns the number of entries in the current `Bundle`
fun size: Int do return native_bundle.size
return string_set
end
- # Add key-value information by dynamically choosing the appropriate
+ # Add key-value information by dynamically choosing the appropriate
# java method according to value type
- # If there's already a value associated with this key, the new value
+ # If there's already a value associated with this key, the new value
# overwrites it
#
# To retrieve entries, you'll have to call the type corresponding method
- # conforming to these rules :
+ # conforming to these rules:
#
# | Nit type | corresponding getter |
# |:----------------------|:--------------------------------|
- # ! `Int` | `long` |
+ # | `Int` | `long` |
# | `Float` | `double` |
# | `Bool` | `bool` |
# | `Char` | `char` |
- # ! `String` | `string` |
- # ! `Serializable` | `deserialize` |
- # ! `Array[Int]` | `array_of_long` |
- # ! `Array[Float]` | `array_of_double` |
- # ! `Array[Bool]` | `array_of_bool` |
- # ! `Array[Char]` | `array_of_char` |
- # ! `Array[String]` | `array_of_string` |
+ # | `String` | `string` |
+ # | `Serializable` | `deserialize` |
+ # | `Array[Int]` | `array_of_long` |
+ # | `Array[Float]` | `array_of_double` |
+ # | `Array[Bool]` | `array_of_bool` |
+ # | `Array[Char]` | `array_of_char` |
+ # | `Array[String]` | `array_of_string` |
# | `Array[Serializable]` | `deserialize_array` |
fun []=(key: String, value: Serializable): Bundle
do
# Retrieve an `Object` serialized via `[]=` function
# Returns `null` if there's no serialized object corresponding to the given key
# or if it's the wrong value type
- # Make sure that the serialized object is `auto_serializable` or that it
+ # Make sure that the serialized object is `auto_serializable` or that it
# redefines the appropriate methods. Refer to `Serializable` documentation
# for further details
fun deserialize(key: String): nullable Object
# Retrieve an `Array` of `Object` serialized via `[]=` function
# Returns `null` if there's no serialized `Array` corresponding to the given key
# or if it's the wrong value type
- # Make sure that the serialized objects are `auto_serializable` or that they
+ # Make sure that the serialized objects are `auto_serializable` or that they
# redefine the appropriate methods. Refer to `Serializable` documentation
# for further details
fun deserialize_array(key: String): nullable Array[nullable Object]
fun bool(key: String, def_value: Bool): Bool
do
sys.jni_env.push_local_frame(1)
- var return_value =
+ var return_value =
native_bundle.get_boolean_with_def_value(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
return return_value
fun char(key: String, def_value: Char): Char
do
sys.jni_env.push_local_frame(1)
- var return_value =
+ var return_value =
native_bundle.get_char_with_def_value(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
return return_value
fun int(key: String, def_value: Int): Int
do
sys.jni_env.push_local_frame(1)
- var return_value =
+ var return_value =
native_bundle.get_long_with_def_value(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
return return_value
end
-
+
# Retrieves the `Float` value corresponding to the given key
# Returns the `def_value` if none or if it's the wrong value type
fun float(key: String, def_value: Float): Float
do
sys.jni_env.push_local_frame(1)
- var return_value =
+ var return_value =
native_bundle.get_double_with_def_value(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
return return_value
var return_value = native_bundle.get_string_array(key.to_java_string)
sys.jni_env.pop_local_frame
-
+
if return_value.is_empty then return null
return return_value
bundle.put_char_array(key, self)
else if self isa Array[String] then
sys.jni_env.push_local_frame(self.length)
- var java_string_array = new Array[JavaString]
+ var java_string_array = new Array[JavaString]
for element in self do
java_string_array.push(element.to_s.to_java_string)
`}
# Start tracking head movement
- fun start_tracking in "Java" `{ recv.startTracking(); `}
+ fun start_tracking in "Java" `{ self.startTracking(); `}
# Stop tracking head movement
- fun stop_tracking in "Java" `{ recv.stopTracking(); `}
+ fun stop_tracking in "Java" `{ self.stopTracking(); `}
# Apply correction to the gyroscope values
fun gyro_bias=(matrix: JavaFloatArray) in "Java" `{
- recv.setGyroBias(matrix);
+ self.setGyroBias(matrix);
`}
# Enable finer analysis using the neck as center of movement
fun neck_model_enabled=(value: Bool) in "Java" `{
- recv.setNeckModelEnabled(value);
+ self.setNeckModelEnabled(value);
`}
# Fill `matrix` with the last rotation matrix calculated from head movements
#
# Require: matrix.length >= offset + 16
fun last_head_view(matrix: JavaFloatArray, offset: Int) in "Java" `{
- recv.getLastHeadView(matrix, (int)offset);
+ self.getLastHeadView(matrix, (int)offset);
`}
end
end
private fun find_class_loader(native_activity: NativeActivity) import jni_env, class_loader=, JavaObject.as nullable, class_loader_method=, JMethodID.as nullable `{
- JNIEnv *env = Sys_jni_env(recv);
+ JNIEnv *env = Sys_jni_env(self);
// Retrieve main activity
jclass class_activity = (*env)->GetObjectClass(env, native_activity);
}
// Return the values to Nit
- Sys_class_loader__assign(recv, JavaObject_as_nullable((*env)->NewGlobalRef(env, instance_class_loader)));
- Sys_class_loader_method__assign(recv, JMethodID_as_nullable(class_class_loader_findClass));
+ Sys_class_loader__assign(self, JavaObject_as_nullable((*env)->NewGlobalRef(env, instance_class_loader)));
+ Sys_class_loader_method__assign(self, JMethodID_as_nullable(class_class_loader_findClass));
// Clean up
(*env)->DeleteLocalRef(env, class_activity);
`}
private fun load_jclass_intern(instance_class_loader: JavaObject, class_loader_findClass: JMethodID, name: NativeString): JClass import jni_env `{
- JNIEnv *env = Sys_jni_env(recv);
+ JNIEnv *env = Sys_jni_env(self);
jobject class_name = (*env)->NewStringUTF(env, name);
jclass java_class = (*env)->CallObjectMethod(env, instance_class_loader, class_loader_findClass, class_name);
private extern class NativeAndroidMotionEvent `{AInputEvent *`}
fun pointers_count: Int `{
- return AMotionEvent_getPointerCount(recv);
+ return AMotionEvent_getPointerCount(self);
`}
# Did this motion event just started?
fun just_went_down: Bool `{
- return (AMotionEvent_getAction(recv) & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_DOWN;
+ return (AMotionEvent_getAction(self) & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_DOWN;
`}
fun edge: Int `{
- return AMotionEvent_getEdgeFlags(recv);
+ return AMotionEvent_getEdgeFlags(self);
`}
# Get the non-primary pointer id that just went down (returns -1 or > 0)
fun index_down_pointer: Int `{
- int a = AMotionEvent_getAction(recv);
+ int a = AMotionEvent_getAction(self);
if ((a & AMOTION_EVENT_ACTION_MASK) == AMOTION_EVENT_ACTION_POINTER_DOWN)
return (a & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
else return -1;
`}
- fun action: AMotionEventAction `{ return AMotionEvent_getAction(recv); `}
+ fun action: AMotionEventAction `{ return AMotionEvent_getAction(self); `}
end
private extern class AMotionEventAction `{ int32_t `}
- fun action: Int `{ return recv & AMOTION_EVENT_ACTION_MASK; `}
+ fun action: Int `{ return self & AMOTION_EVENT_ACTION_MASK; `}
fun is_down: Bool do return action == 0
fun is_up: Bool do return action == 1
super KeyEvent
super AndroidInputEvent
- private fun action: Int `{ return AKeyEvent_getAction(recv); `}
+ private fun action: Int `{ return AKeyEvent_getAction(self); `}
redef fun is_down: Bool do return action == 0
redef fun is_up: Bool do return action == 1
# Hardware code of the key raising this event
- fun key_code: Int `{ return AKeyEvent_getKeyCode(recv); `}
+ fun key_code: Int `{ return AKeyEvent_getKeyCode(self); `}
redef fun to_c `{
- int code = AKeyEvent_getKeyCode(recv);
+ int code = AKeyEvent_getKeyCode(self);
if (code >= AKEYCODE_0 && code <= AKEYCODE_9)
return '0'+code-AKEYCODE_0;
if (code >= AKEYCODE_A && code <= AKEYCODE_Z)
new in "Java" `{ return new Intent(); `}
- fun add_category(category: JavaString) in "Java" `{ recv.addCategory(category); `}
- fun add_flags(flags: Int) in "Java" `{ recv.addFlags((int)flags); `}
+ fun add_category(category: JavaString) in "Java" `{ self.addCategory(category); `}
+ fun add_flags(flags: Int) in "Java" `{ self.addFlags((int)flags); `}
fun filter_equals(other: NativeIntent): Bool in "Java" `{
- return recv.filterEquals(other);
+ return self.filterEquals(other);
`}
- fun action: JavaString in "Java" `{ return recv.getAction(); `}
+ fun action: JavaString in "Java" `{ return self.getAction(); `}
fun boolean_array_extra(name: JavaString): Array[Bool] import Array[Bool],
Array[Bool].push in "Java" `{
- boolean[] java_array = recv.getBooleanArrayExtra(name);
+ boolean[] java_array = self.getBooleanArrayExtra(name);
int nit_array = new_Array_of_Bool();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun boolean_extra(name: JavaString, def_value: Bool): Bool in "Java" `{
- return recv.getBooleanExtra(name, def_value);
+ return self.getBooleanExtra(name, def_value);
`}
fun byte_array_extra(name: JavaString): Array[Int] import Array[Int],
Array[Int].add in "Java" `{
- byte[] java_array = recv.getByteArrayExtra(name);
+ byte[] java_array = self.getByteArrayExtra(name);
int nit_array = new_Array_of_Int();
for (int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun byte_extra(name: JavaString, def_value: Int): Int in "Java" `{
- return (int) recv.getByteExtra(name, (byte) def_value);
+ return (int) self.getByteExtra(name, (byte) def_value);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun char_array_extra(name: JavaString): Array[Char] import Array[Char],
Array[Char].add in "Java" `{
- char[] java_array = recv.getCharArrayExtra(name);
+ char[] java_array = self.getCharArrayExtra(name);
int nit_array = new_Array_of_Char();
for (int i = 0; i < java_array.length; ++i)
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun char_extra(name: JavaString, def_value: Char): Char in "Java" `{
- return recv.getCharExtra(name, def_value);
+ return self.getCharExtra(name, def_value);
`}
fun char_sequence_array_extra(name: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- CharSequence[] java_array = recv.getCharSequenceArrayExtra(name);
+ CharSequence[] java_array = self.getCharSequenceArrayExtra(name);
int nit_array = new_StringCopyArray();
for (int i = 0; i < java_array.length; ++i)
`}
fun char_sequence_array_list_extra(name: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- ArrayList<CharSequence> java_array = recv.getCharSequenceArrayListExtra(name);
+ ArrayList<CharSequence> java_array = self.getCharSequenceArrayListExtra(name);
int nit_array = new_StringCopyArray();
if (java_array == null) return nit_array;
return StringCopyArray_collection(nit_array);
`}
fun char_sequence_extra(name: JavaString): JavaString in "Java" `{
- return (String) recv.getCharSequenceExtra(name);
+ return (String) self.getCharSequenceExtra(name);
`}
fun categories: HashSet[String] import StringCopyHashSet,
StringCopyHashSet.add, StringCopyHashSet.collection in "Java" `{
- Set<String> java_set = recv.getCategories();
+ Set<String> java_set = self.getCategories();
int nit_hashset = new_StringCopyHashSet();
if (java_set == null) return nit_hashset;
return StringCopyHashSet_collection(nit_hashset);
`}
# Returns the Uri as an encoded String
- fun data: JavaString in "Java" `{ return recv.getDataString(); `}
+ fun data: JavaString in "Java" `{ return self.getDataString(); `}
fun double_array_extra(name: JavaString): Array[Float] import Array[Float],
Array[Float].push in "Java" `{
- double[] java_array = recv.getDoubleArrayExtra(name);
+ double[] java_array = self.getDoubleArrayExtra(name);
int nit_array = new_Array_of_Float();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun double_extra(name: JavaString, def_value: Float): Float in "Java" `{
- return recv.getDoubleExtra(name, def_value);
+ return self.getDoubleExtra(name, def_value);
`}
- fun flags: Int in "Java" `{ return recv.getFlags(); `}
+ fun flags: Int in "Java" `{ return self.getFlags(); `}
fun float_array_extra(name: JavaString): Array[Float] import Array[Float],
Array[Float].push in "Java" `{
- float[] java_array = recv.getFloatArrayExtra(name);
+ float[] java_array = self.getFloatArrayExtra(name);
int nit_array = new_Array_of_Float();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun float_extra(name: JavaString, def_value: Float): Float in "Java" `{
- return recv.getFloatExtra(name, (float) def_value);
+ return self.getFloatExtra(name, (float) def_value);
`}
fun int_array_extra(name: JavaString): Array[Int] import Array[Int],
Array[Int].push in "Java" `{
- int[] java_array = recv.getIntArrayExtra(name);
+ int[] java_array = self.getIntArrayExtra(name);
int nit_array = new_Array_of_Int();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun int_extra(name: JavaString, def_value: Int): Int in "Java" `{
- return recv.getIntExtra(name, (int)def_value);
+ return self.getIntExtra(name, (int)def_value);
`}
fun long_array_extra(name: JavaString): Array[Int] import Array[Int],
Array[Int].push in "Java" `{
- long[] java_array = recv.getLongArrayExtra(name);
+ long[] java_array = self.getLongArrayExtra(name);
int nit_array = new_Array_of_Int();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun long_extra(name: JavaString, def_value: Int): Int in "Java" `{
- return (int) recv.getLongExtra(name, def_value);
+ return (int) self.getLongExtra(name, def_value);
`}
- fun get_package: JavaString in "Java" `{ return recv.getPackage(); `}
- fun scheme: JavaString in "Java" `{ return recv.getScheme(); `}
+ fun get_package: JavaString in "Java" `{ return self.getPackage(); `}
+ fun scheme: JavaString in "Java" `{ return self.getScheme(); `}
fun short_array_extra(name: JavaString): Array[Int] import Array[Int],
Array[Int].push in "Java" `{
- short[] java_array = recv.getShortArrayExtra(name);
+ short[] java_array = self.getShortArrayExtra(name);
int nit_array = new_Array_of_Int();
for(int i=0; i < java_array.length; ++i)
return nit_array;
`}
fun short_extra(name: JavaString, def_value: Int): Int in "Java" `{
- return recv.getShortExtra(name, (short) def_value);
+ return self.getShortExtra(name, (short) def_value);
`}
fun string_array_extra(name: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- String[] java_array = recv.getStringArrayExtra(name);
+ String[] java_array = self.getStringArrayExtra(name);
int nit_array = new_StringCopyArray();
for(int i=0; i < java_array.length; ++i)
`}
fun string_array_list_extra(name: JavaString): Array[String]
import StringCopyArray, StringCopyArray.add, StringCopyArray.collection in "Java" `{
- ArrayList<String> java_array = recv.getStringArrayListExtra(name);
+ ArrayList<String> java_array = self.getStringArrayListExtra(name);
int nit_array = new_StringCopyArray();
for (String element: java_array)
return StringCopyArray_collection(nit_array);
`}
fun string_extra(name: JavaString): JavaString in "Java" `{
- String return_value = recv.getStringExtra(name);
+ String return_value = self.getStringExtra(name);
if (return_value == null) return "";
return return_value;
`}
- fun get_type: JavaString in "Java" `{ return recv.getType(); `}
+ fun get_type: JavaString in "Java" `{ return self.getType(); `}
fun has_category(category: JavaString): Bool in "Java" `{
- return recv.hasCategory(category);
+ return self.hasCategory(category);
`}
- fun has_extra(extra: JavaString): Bool in "Java" `{ return recv.hasExtra(extra); `}
- fun has_file_descriptors: Bool in "Java" `{ return recv.hasFileDescriptors(); `}
+ fun has_extra(extra: JavaString): Bool in "Java" `{ return self.hasExtra(extra); `}
+ fun has_file_descriptors: Bool in "Java" `{ return self.hasFileDescriptors(); `}
fun add_extra_double(name: JavaString, value: Float): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_double(name: JavaString, value: Array[Float]): NativeIntent
import Array[Float].length, Array[Float].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Float__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun add_extra_char(name: JavaString, value: Char): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
# FIXME: Java's `char` are encoded on 16-bits whereas Nit's are on 8-bits.
fun add_extra_array_of_char(name: JavaString, value: Array[Char]): NativeIntent
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Char__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_char_sequence(name: JavaString, value: JavaString): NativeIntent
in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_char_sequence(name: JavaString, value: Array[JavaString]):
NativeIntent import Array[JavaString].length, Array[JavaString].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_JavaString__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_bundle(name: JavaString, value: NativeBundle): NativeIntent
in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_int(name: JavaString, value: Int): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_int(name: JavaString, value: Array[Int]): NativeIntent
import Array[Int].length, Array[Int].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = (int)Array_of_Int__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_array_list_of_int(name: JavaString, value: Array[Int]): NativeIntent
import Array[Int].length, Array[Int].[] in "Java" `{
for (int i=0; i < length; ++i)
java_array.add((int)Array_of_Int__index(value, i));
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_byte(name: JavaString, value: Int): NativeIntent in "Java" `{
- return recv.putExtra(name, (byte) value);
+ return self.putExtra(name, (byte) value);
`}
fun add_extra_array_of_byte(name: JavaString, value: Int): NativeIntent in "Java" `{
- return recv.putExtra(name, (byte) value);
+ return self.putExtra(name, (byte) value);
`}
fun add_extra_long(name: JavaString, value: Int): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_long(name: JavaString, value: Array[Int]): NativeIntent
import Array[Int].length, Array[Int].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Int__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_float(name: JavaString, value: Float): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_float(name: JavaString, value: Array[Float]): NativeIntent
import Array[Float].length, Array[Float].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = (float) Array_of_Float__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_string(name: JavaString, value: JavaString): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_string(name: JavaString, value: Array[JavaString]): NativeIntent
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_JavaString__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_array_list_of_string(name: JavaString, value: Array[JavaString]): NativeIntent
import Array[JavaString].length, Array[JavaString].[] in "Java" `{
java_array.add(Array_of_JavaString__index(value, i));
}
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_bool(name: JavaString, value: Bool): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_bool(name: JavaString, value: Array[Bool]): NativeIntent
import Array[Bool].length, Array[Bool].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = Array_of_Bool__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
fun add_extra_short(name: JavaString, value: Int): NativeIntent in "Java" `{
- return recv.putExtra(name, value);
+ return self.putExtra(name, value);
`}
fun add_extra_array_of_short(name: JavaString, value: Array[Int]): NativeIntent
import Array[Int].length, Array[Int].[] in "Java" `{
for (int i=0; i < java_array.length; ++i)
java_array[i] = (short) Array_of_Int__index(value, i);
- return recv.putExtra(name, java_array);
+ return self.putExtra(name, java_array);
`}
- fun copy_extras(src: NativeIntent): NativeIntent in "Java" `{ return recv.putExtras(src); `}
- fun add_extras(src: NativeBundle): NativeIntent in "Java" `{ return recv.putExtras(src); `}
- fun remove_category(category: JavaString) in "Java" `{ recv.removeCategory(category); `}
- fun remove_extra(name: JavaString) in "Java" `{ recv.removeExtra(name); `}
+ fun copy_extras(src: NativeIntent): NativeIntent in "Java" `{ return self.putExtras(src); `}
+ fun add_extras(src: NativeBundle): NativeIntent in "Java" `{ return self.putExtras(src); `}
+ fun remove_category(category: JavaString) in "Java" `{ self.removeCategory(category); `}
+ fun remove_extra(name: JavaString) in "Java" `{ self.removeExtra(name); `}
fun replace_extras(src: NativeIntent): NativeIntent in "Java" `{
- return recv.replaceExtras(src);
+ return self.replaceExtras(src);
`}
fun resolve_activity(pm: NativePackageManager): NativeComponentName in "Java" `{
- return recv.resolveActivity(pm);
+ return self.resolveActivity(pm);
`}
fun resolve_type(context: NativeActivity): JavaString in "Java" `{
- return recv.resolveType(context);
+ return self.resolveType(context);
`}
- fun action=(action: JavaString): NativeIntent in "Java" `{ return recv.setAction(action); `}
+ fun action=(action: JavaString): NativeIntent in "Java" `{ return self.setAction(action); `}
fun class_=(package_context: NativeActivity, class_name: JavaString): NativeIntent
in "Java" `{
Class<?> java_class = null;
} catch (Exception e) {
e.getStackTrace();
}
- return recv.setClass(package_context, java_class);
+ return self.setClass(package_context, java_class);
`}
fun class_name=(package_context: NativeActivity, class_name: JavaString): NativeIntent
in "Java" `{
- return recv.setClassName(package_context, class_name);
+ return self.setClassName(package_context, class_name);
`}
fun set_class_name(package_name: JavaString, class_name: JavaString): NativeIntent
in "Java" `{
- return recv.setClassName(package_name, class_name);
+ return self.setClassName(package_name, class_name);
`}
fun data=(data_uri: JavaString): NativeIntent in "Java" `{
- return recv.setData(Uri.parse(data_uri));
+ return self.setData(Uri.parse(data_uri));
`}
fun data_and_type=(data_uri: JavaString, type_: JavaString): NativeIntent in "Java" `{
- return recv.setDataAndType(Uri.parse(data_uri), type_);
+ return self.setDataAndType(Uri.parse(data_uri), type_);
`}
- fun flags=(flags: Int): NativeIntent in "Java" `{ return recv.setFlags((int)flags); `}
+ fun flags=(flags: Int): NativeIntent in "Java" `{ return self.setFlags((int)flags); `}
fun package_name=(package_name: JavaString): NativeIntent in "Java" `{
- return recv.setPackage(package_name);
+ return self.setPackage(package_name);
`}
fun source_bounds=(left, top, right, bottom: Int) in "Java" `{
- recv.setSourceBounds(new Rect((int)left, (int)top, (int)right, (int)bottom));
+ self.setSourceBounds(new Rect((int)left, (int)top, (int)right, (int)bottom));
`}
fun mime_type=(mime_type: JavaString): NativeIntent in "Java" `{
- return recv.setType(mime_type);
+ return self.setType(mime_type);
`}
- fun to_native_s: JavaString in "Java" `{ return recv.toString(); `}
- fun to_uri(flags: Int): JavaString in "Java" `{ return recv.toUri((int)flags); `}
+ fun to_native_s: JavaString in "Java" `{ return self.toString(); `}
+ fun to_uri(flags: Int): JavaString in "Java" `{ return self.toUri((int)flags); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeIntent_sys(recv);
+ Sys sys = NativeIntent_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
end
redef extern class NativeActivity
- private fun start_activity(intent: NativeIntent) in "Java" `{ recv.startActivity(intent); `}
- private fun start_service(intent: NativeIntent) in "Java" `{ recv.startService(intent); `}
- private fun stop_service(intent: NativeIntent) in "Java" `{ recv.stopService(intent); `}
+ private fun start_activity(intent: NativeIntent) in "Java" `{ self.startActivity(intent); `}
+ private fun start_service(intent: NativeIntent) in "Java" `{ self.startService(intent); `}
+ private fun stop_service(intent: NativeIntent) in "Java" `{ self.stopService(intent); `}
end
# Allows user to get values with enum-like syntax : `intent_action.main`
`}
redef extern class NativeIntent
- fun selector=(selector: NativeIntent) in "Java" `{ recv.setSelector(selector); `}
+ fun selector=(selector: NativeIntent) in "Java" `{ self.setSelector(selector); `}
end
redef class Category
`}
redef extern class NativeIntent
- fun set_data_and_normalize(data_uri: JavaString): NativeIntent in "Java" `{ return recv.setDataAndNormalize(Uri.parse(data_uri)); `}
- fun set_data_and_type_and_normalize(data_uri: JavaString, type_: JavaString): NativeIntent in "Java" `{ return recv.setDataAndTypeAndNormalize(Uri.parse(data_uri), type_); `}
- fun set_mime_type_and_normalize(mime_type: JavaString): NativeIntent in "Java" `{ return recv.setTypeAndNormalize(mime_type); `}
+ fun set_data_and_normalize(data_uri: JavaString): NativeIntent in "Java" `{ return self.setDataAndNormalize(Uri.parse(data_uri)); `}
+ fun set_data_and_type_and_normalize(data_uri: JavaString, type_: JavaString): NativeIntent in "Java" `{ return self.setDataAndTypeAndNormalize(Uri.parse(data_uri), type_); `}
+ fun set_mime_type_and_normalize(mime_type: JavaString): NativeIntent in "Java" `{ return self.setTypeAndNormalize(mime_type); `}
end
redef class Extra
int event;
void* source;
while ((ident=ALooper_pollAll(timeout_ms, NULL, &event, &source)) >= 0) {
- App_handle_looper_event(recv, ident, event, source);
+ App_handle_looper_event(self, ident, event, source);
}
`}
destroy, start, resume, low_memory, config_changed, input_changed,
window_resized, window_redraw_needed, content_rect_changed `{
- struct android_app *app_glue = App_native_app_glue(recv);
+ struct android_app *app_glue = App_native_app_glue(self);
struct android_poll_source* source = (struct android_poll_source*)data;
// Process this event.
#fun set_callbacks_handler(handler: App) or callbacks= ...
# Java VM associated to `self`
- fun vm: JavaVM `{ return recv->vm; `}
+ fun vm: JavaVM `{ return self->vm; `}
# JNI environmnet associated to `self`
- fun env: JniEnv `{ return recv->env; `}
+ fun env: JniEnv `{ return self->env; `}
# The `NativeActivity`, as in the Java object, associated to `self`
- fun java_native_activity: NativeActivity `{ return recv->clazz; `}
+ fun java_native_activity: NativeActivity `{ return self->clazz; `}
# Path to this application's internal data directory.
- fun internal_data_path: NativeString `{ return (char*)recv->internalDataPath; `}
+ fun internal_data_path: NativeString `{ return (char*)self->internalDataPath; `}
# Path to this application's external (removable/mountable) data directory.
- fun external_data_path: NativeString `{ return (char*)recv->externalDataPath; `}
+ fun external_data_path: NativeString `{ return (char*)self->externalDataPath; `}
# The platform's SDK version code.
- fun sdk_version: Int `{ return recv->sdkVersion; `}
+ fun sdk_version: Int `{ return self->sdkVersion; `}
# This is the native instance of the application. It is not used by
# the framework, but can be set by the application to its own instance
# state.
- fun instance: Pointer `{ return recv->instance; `}
+ fun instance: Pointer `{ return self->instance; `}
# Pointer to the Asset Manager instance for the application. The application
# uses this to access binary assets bundled inside its own .apk file.
#
# TODO activate in a future `asset_manager` module if it cannot be done in Java
- #fun asset_manager: AssetManager `{ return recv->assetManager; `}
+ #fun asset_manager: AssetManager `{ return self->assetManager; `}
# Available starting with Honeycomb: path to the directory containing
# the application's OBB files (if any). If the app doesn't have any
# api?
#
# TODO activate in a future module at API 11
- #fun obb_path: NativeString `{ return (char*)recv->obbPath; `}
+ #fun obb_path: NativeString `{ return (char*)self->obbPath; `}
end
# This is the interface for the standard glue code of a threaded
extern class NativeAppGlue `{ struct android_app* `}
# We use the `userData` field of the C structure to store an handle to
# the associated App
- private fun user_data: App `{ return recv->userData; `}
+ private fun user_data: App `{ return self->userData; `}
private fun user_data=(val: App) `{
App_incr_ref(val);
- recv->userData = val;
+ self->userData = val;
`}
# Fill this in with the function to process input events. At this point
#fun set_input_event_handler(handler: App) `{ `}
# The ANativeActivity object instance that this app is running in.
- fun ndk_native_activity: NdkNativeActivity `{ return recv->activity; `}
+ fun ndk_native_activity: NdkNativeActivity `{ return self->activity; `}
# The current configuration the app is running in.
- fun config: AConfiguration `{ return recv->config; `}
+ fun config: AConfiguration `{ return self->config; `}
# This is the last instance's saved state, as provided at creation time.
# It is NULL if there was no state. You can use this as you need; the
# at which point they will be initialized to NULL and you can malloc your
# state and place the information here. In that case the memory will be
# freed for you later.
- fun saved_state: Pointer `{ return recv->savedState; `}
- fun saved_state_size: Int `{ return recv->savedStateSize; `}
+ fun saved_state: Pointer `{ return self->savedState; `}
+ fun saved_state_size: Int `{ return self->savedStateSize; `}
# The ALooper associated with the app's thread.
- fun looper: ALooper `{ return recv->looper; `}
+ fun looper: ALooper `{ return self->looper; `}
# When non-NULL, this is the input queue from which the app will
# receive user input events.
- fun input_queue: AInputQueue `{ return recv->inputQueue; `}
+ fun input_queue: AInputQueue `{ return self->inputQueue; `}
# When non-NULL, this is the window surface that the app can draw in.
- fun window: ANativeWindow `{ return recv->window; `}
+ fun window: ANativeWindow `{ return self->window; `}
# Current content rectangle of the window; this is the area where the
# window's content should be placed to be seen by the user.
#
# TODO activate when we know what to return (returns a struct not a pointer)
- #fun content_recv: ARect `{ return recv->contentRect; `}
+ #fun content_self: ARect `{ return self->contentRect; `}
# Current state of the app's activity. May be either APP_CMD_START,
# APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
- fun activity_state: Int `{ return recv->activityState; `}
+ fun activity_state: Int `{ return self->activityState; `}
# This is non-zero when the application's NativeActivity is being
# destroyed and waiting for the app thread to complete.
- fun detroy_request: Bool `{ return recv->destroyRequested; `}
+ fun detroy_request: Bool `{ return self->destroyRequested; `}
end
# Android NDK's struture holding configurations of the native app
Activity.on_start, Activity.on_restart, Activity.on_stop,
Activity.on_pause, Activity.on_resume,
Activity.on_save_instance_state, Activity.on_restore_instance_state `{
- App_incr_ref(recv);
- global_app = recv;
+ App_incr_ref(self);
+ global_app = self;
`}
# Create the Nit side to this new `native` Java activity, and return it to Java
redef class NativeActivity
fun notification_manager: NativeNotificationManager in "Java" `{
- return (NotificationManager)recv.getSystemService(Context.NOTIFICATION_SERVICE);
+ return (NotificationManager)self.getSystemService(Context.NOTIFICATION_SERVICE);
`}
end
extern class NativeNotificationManager in "Java" `{ android.app.NotificationManager `}
fun notify(tag: JavaString, id: Int, notif: NativeNotification) in "Java" `{
- recv.notify(tag, (int)id, notif);
+ self.notify(tag, (int)id, notif);
`}
- fun cancel(tag: JavaString, id: Int) in "Java" `{ recv.cancel(tag, (int)id); `}
+ fun cancel(tag: JavaString, id: Int) in "Java" `{ self.cancel(tag, (int)id); `}
- fun cancel_all in "Java" `{ recv.cancelAll(); `}
+ fun cancel_all in "Java" `{ self.cancelAll(); `}
end
extern class NativeNotification in "Java" `{ android.app.Notification `}
fun create: NativeNotification in "Java" `{
// Deprecated since API 16, which introduces `build`,
// refinement and global compilation should prevent warnings.
- return recv.getNotification();
+ return self.getNotification();
`}
- fun title=(value: JavaString) in "Java" `{ recv.setContentTitle(value); `}
+ fun title=(value: JavaString) in "Java" `{ self.setContentTitle(value); `}
- fun text=(value: JavaString) in "Java" `{ recv.setContentText(value); `}
+ fun text=(value: JavaString) in "Java" `{ self.setContentText(value); `}
- fun ticker=(value: JavaString) in "Java" `{ recv.setTicker(value); `}
+ fun ticker=(value: JavaString) in "Java" `{ self.setTicker(value); `}
- fun small_icon=(value: Int) in "Java" `{ recv.setSmallIcon((int)value); `}
+ fun small_icon=(value: Int) in "Java" `{ self.setSmallIcon((int)value); `}
- fun auto_cancel=(value: Bool) in "Java" `{ recv.setAutoCancel(value); `}
+ fun auto_cancel=(value: Bool) in "Java" `{ self.setAutoCancel(value); `}
- fun number=(value: Int) in "Java" `{ recv.setNumber((int)value); `}
+ fun number=(value: Int) in "Java" `{ self.setNumber((int)value); `}
- fun ongoing=(value: Bool) in "Java" `{ recv.setOngoing(value); `}
+ fun ongoing=(value: Bool) in "Java" `{ self.setOngoing(value); `}
end
extern class ASensorType `{int`}
new accelerometer: ASensorType `{return ASENSOR_TYPE_ACCELEROMETER;`}
- fun is_accelerometer: Bool `{return recv == ASENSOR_TYPE_ACCELEROMETER;`}
+ fun is_accelerometer: Bool `{return self == ASENSOR_TYPE_ACCELEROMETER;`}
new magnetic_field: ASensorType `{return ASENSOR_TYPE_MAGNETIC_FIELD;`}
- fun is_magnetic_field: Bool `{return recv == ASENSOR_TYPE_MAGNETIC_FIELD;`}
+ fun is_magnetic_field: Bool `{return self == ASENSOR_TYPE_MAGNETIC_FIELD;`}
new gyroscope:ASensorType `{return ASENSOR_TYPE_GYROSCOPE;`}
- fun is_gyroscope: Bool `{ return recv == ASENSOR_TYPE_GYROSCOPE;`}
+ fun is_gyroscope: Bool `{ return self == ASENSOR_TYPE_GYROSCOPE;`}
new light: ASensorType `{return ASENSOR_TYPE_LIGHT;`}
- fun is_light: Bool `{return recv == ASENSOR_TYPE_LIGHT;`}
+ fun is_light: Bool `{return self == ASENSOR_TYPE_LIGHT;`}
new proximity: ASensorType `{return ASENSOR_TYPE_PROXIMITY;`}
- fun is_proximity:Bool `{return recv == ASENSOR_TYPE_PROXIMITY;`}
+ fun is_proximity:Bool `{return self == ASENSOR_TYPE_PROXIMITY;`}
end
# Manages the sensors
# Returns the list of available sensors
fun get_sensor_list: Pointer `{
ASensorList *list;
- ASensorManager_getSensorList(recv, list);
+ ASensorManager_getSensorList(self, list);
return list;
`}
# Create a new sensor event queue and associate it with a looper
fun create_event_queue(app: NativeAppGlue): ASensorEventQueue `{
- return ASensorManager_createEventQueue(recv, app->looper, LOOPER_ID_USER, NULL, NULL);
+ return ASensorManager_createEventQueue(self, app->looper, LOOPER_ID_USER, NULL, NULL);
`}
# Returns the default sensor of the given type
fun get_default_sensor(sensortype: ASensorType): ASensor `{
- return ASensorManager_getDefaultSensor(recv, sensortype);
+ return ASensorManager_getDefaultSensor(self, sensortype);
`}
# Destroys the event queue and free all resources associated to it
fun destroy_event_queue(queue: ASensorEventQueue) `{
- ASensorManager_destroyEventQueue(recv, queue);
+ ASensorManager_destroyEventQueue(self, queue);
`}
end
# Enable the selected sensor, returns a negative value on error
fun enable_sensor(sensor: ASensor): Int `{
- return ASensorEventQueue_enableSensor(recv, sensor);
+ return ASensorEventQueue_enableSensor(self, sensor);
`}
# Disable the selected sensor, returns a negative value on error
fun disable_sensor(sensor: ASensor): Int `{
- return ASensorEventQueue_disableSensor(recv, sensor);
+ return ASensorEventQueue_disableSensor(self, sensor);
`}
# Set the delivery rate of events in microseconds for the given sensor
fun set_event_rate(sensor: ASensor, usec: Int): Int `{
- return ASensorEventQueue_setEventRate(recv, sensor, usec);
+ return ASensorEventQueue_setEventRate(self, sensor, usec);
`}
# Returns 1 if the queue has events, 0 if it does not have events,
# and a negative value if there is an error
fun has_events: Int `{
- return ASensorEventQueue_hasEvents(recv);
+ return ASensorEventQueue_hasEvents(self);
`}
# Returns the next available events from the queue.
# Returns a negative value if no events are available or an error has occured
# otherwise the number of events returned
fun get_events(events: ASensorEvents, count: Int): Int `{
- return ASensorEventQueue_getEvents(recv, events, (size_t)count);
+ return ASensorEventQueue_getEvents(self, events, (size_t)count);
`}
end
extern class ASensor `{ASensorRef`}
new `{return malloc(sizeof(ASensorRef));`}
- fun name: NativeString `{return (char*)ASensor_getName(recv);`}
- fun vendor: NativeString `{return (char*)ASensor_getVendor(recv);`}
- fun sensor_type: ASensorType `{return ASensor_getType(recv);`}
- fun resolution: Float `{return ASensor_getResolution(recv);`}
- fun min_delay: Int `{return ASensor_getMinDelay(recv);`}
+ fun name: NativeString `{return (char*)ASensor_getName(self);`}
+ fun vendor: NativeString `{return (char*)ASensor_getVendor(self);`}
+ fun sensor_type: ASensorType `{return ASensor_getType(self);`}
+ fun resolution: Float `{return ASensor_getResolution(self);`}
+ fun min_delay: Int `{return ASensor_getMinDelay(self);`}
end
# NIT representation of an Android Sensor used in android_app to initialize sensors
extern class ASensorEvent `{ASensorEvent*`}
super SensorEvent
- fun version: Int `{return recv->version;`}
- fun sensor: ASensor `{return (ASensorRef)recv->sensor;`}
- fun sensor_type: ASensorType `{return recv->type;`}
- fun timestamp: Int `{return recv->timestamp;`}
+ fun version: Int `{return self->version;`}
+ fun sensor: ASensor `{return (ASensorRef)self->sensor;`}
+ fun sensor_type: ASensorType `{return self->type;`}
+ fun timestamp: Int `{return self->timestamp;`}
end
extern class FullSensor `{ASensorEvent*`}
super ASensorLight
super ASensorProximity
- fun temperature: Float `{return recv->temperature;`}
- fun pressure: Float `{return recv->pressure;`}
- fun data: Pointer `{return recv->data;`}
- fun vector: ASensorVector `{return &(recv->vector);`}
- fun acceleration: ASensorVector `{return &(recv->acceleration);`}
- fun magnetic: ASensorVector `{return &(recv->magnetic);`}
+ fun temperature: Float `{return self->temperature;`}
+ fun pressure: Float `{return self->pressure;`}
+ fun data: Pointer `{return self->data;`}
+ fun vector: ASensorVector `{return &(self->vector);`}
+ fun acceleration: ASensorVector `{return &(self->acceleration);`}
+ fun magnetic: ASensorVector `{return &(self->magnetic);`}
end
# Extern class referencing a ASensorVector, attribute of ASensorRef
extern class ASensorVector `{ASensorVector*`}
- fun v: Pointer `{return recv->v;`}
- fun x: Float `{ return recv->x;`}
- fun y: Float `{return recv->y;`}
- fun z: Float `{return recv->z;`}
- fun azimuth: Float `{return recv->azimuth;`}
- fun pitch: Float `{return recv->pitch;`}
- fun roll: Float `{return recv->roll;`}
- fun status: Int `{return recv->status;`}
- fun reserved: Pointer `{return recv->reserved;`}
+ fun v: Pointer `{return self->v;`}
+ fun x: Float `{ return self->x;`}
+ fun y: Float `{return self->y;`}
+ fun z: Float `{return self->z;`}
+ fun azimuth: Float `{return self->azimuth;`}
+ fun pitch: Float `{return self->pitch;`}
+ fun roll: Float `{return self->roll;`}
+ fun status: Int `{return self->status;`}
+ fun reserved: Pointer `{return self->reserved;`}
end
# Sensor event returned by the Accelerometer sensor
extern class ASensorAccelerometer `{ASensorEvent*`}
super ASensorEvent
- fun x: Float `{return recv->acceleration.x;`}
- fun y: Float `{return recv->acceleration.y;`}
- fun z: Float `{return recv->acceleration.z;`}
+ fun x: Float `{return self->acceleration.x;`}
+ fun y: Float `{return self->acceleration.y;`}
+ fun z: Float `{return self->acceleration.z;`}
end
# Sensor event returned by the Magnetic Field sensor
extern class ASensorMagneticField `{ASensorEvent*`}
super ASensorEvent
- fun x: Float `{return recv->magnetic.x;`}
- fun y: Float `{return recv->magnetic.y;`}
- fun z: Float `{ return recv->magnetic.z;`}
+ fun x: Float `{return self->magnetic.x;`}
+ fun y: Float `{return self->magnetic.y;`}
+ fun z: Float `{ return self->magnetic.z;`}
end
# Sensor event returned by the gyroscope sensor
extern class ASensorGyroscope `{ASensorEvent*`}
super ASensorEvent
- fun x: Float `{return recv->vector.x;`}
- fun y: Float `{return recv->vector.y;`}
- fun z: Float `{return recv->vector.y;`}
+ fun x: Float `{return self->vector.x;`}
+ fun y: Float `{return self->vector.y;`}
+ fun z: Float `{return self->vector.y;`}
end
# Sensor event returned by the Light sensor
extern class ASensorLight `{ASensorEvent*`}
super ASensorEvent
- fun light: Float `{return recv->light;`}
+ fun light: Float `{return self->light;`}
end
# sensor event returned by the Proximity Sensor
extern class ASensorProximity `{ASensorEvent*`}
super ASensorEvent
- fun distance: Float `{return recv->distance;`}
+ fun distance: Float `{return self->distance;`}
end
# Array of SensorEvents
new (length: Int) `{return malloc(sizeof(ASensorEvent)*length);`}
fun [](index: Int): ASensorEvent `{
- return recv+index;
+ return self+index;
`}
end
//maybe add a boolean to the app to know if we want to use Sensor API or ASensorEvent directly ...
ASensorEvent* events = malloc(sizeof(ASensorEvent)*10);
int nbevents;
- ASensorEventQueue* queue = App_eventqueue(recv);
+ ASensorEventQueue* queue = App_eventqueue(self);
while((nbevents = ASensorEventQueue_getEvents(queue, events, 10)) > 0) {
int i;
for(i = 0; i < nbevents; i++){
ASensorEvent event = events[i];
switch (event.type) {
case ASENSOR_TYPE_ACCELEROMETER:
- App_extern_input_sensor_accelerometer(recv, &event);
+ App_extern_input_sensor_accelerometer(self, &event);
break;
case ASENSOR_TYPE_MAGNETIC_FIELD:
- App_extern_input_sensor_magnetic_field(recv, &event);
+ App_extern_input_sensor_magnetic_field(self, &event);
break;
case ASENSOR_TYPE_GYROSCOPE:
- App_extern_input_sensor_gyroscope(recv, &event);
+ App_extern_input_sensor_gyroscope(self, &event);
break;
case ASENSOR_TYPE_LIGHT:
- App_extern_input_sensor_light(recv, &event);
+ App_extern_input_sensor_light(self, &event);
break;
case ASENSOR_TYPE_PROXIMITY:
- App_extern_input_sensor_proximity(recv, &event);
+ App_extern_input_sensor_proximity(self, &event);
break;
}
}
extern class NativeSharedPreferences in "Java" `{ android.content.SharedPreferences `}
super JavaObject
-
- fun contains(key: JavaString): Bool in "Java" `{ return recv.contains(key); `}
+
+ fun contains(key: JavaString): Bool in "Java" `{ return self.contains(key); `}
fun get_all: HashMap[JavaString, JavaObject] import HashMap[JavaString, JavaObject],
- HashMap[JavaString, JavaObject].[]= in "Java" `{
+ HashMap[JavaString, JavaObject].[]= in "Java" `{
Map<String, ?> java_map = null;
int nit_hashmap = new_HashMap_of_JavaString_JavaObject();
try {
- java_map = recv.getAll();
+ java_map = self.getAll();
} catch (NullPointerException e) {
return nit_hashmap;
}
for (Map.Entry<String, ?> entry: java_map.entrySet())
- HashMap_of_JavaString_JavaObject__index_assign(nit_hashmap,
+ HashMap_of_JavaString_JavaObject__index_assign(nit_hashmap,
entry.getKey(), entry.getValue());
return nit_hashmap;
`}
- fun get_boolean(key: JavaString, def_value: Bool): Bool in "Java" `{
+ fun get_boolean(key: JavaString, def_value: Bool): Bool in "Java" `{
boolean return_value;
try {
- return_value = recv.getBoolean(key, def_value);
+ return_value = self.getBoolean(key, def_value);
} catch (ClassCastException e) {
return def_value;
}
return return_value;
`}
- fun get_float(key: JavaString, def_value: Float): Float in "Java" `{
+ fun get_float(key: JavaString, def_value: Float): Float in "Java" `{
float return_value;
try {
- return_value = recv.getFloat(key, (float) def_value);
+ return_value = self.getFloat(key, (float) def_value);
} catch (ClassCastException e) {
return def_value;
}
fun get_int(key: JavaString, def_value: Int): Int in "Java" `{
int return_value;
try {
- return_value = recv.getInt(key, (int)def_value);
+ return_value = self.getInt(key, (int)def_value);
} catch (ClassCastException e) {
return def_value;
}
fun get_long(key: JavaString, def_value: Int): Int in "Java" `{
long return_value;
try {
- return_value = recv.getLong(key, def_value);
+ return_value = self.getLong(key, def_value);
} catch (ClassCastException e) {
return def_value;
}
fun get_string(key: JavaString, def_value: JavaString): JavaString in "Java" `{
String return_value = null;
try {
- return_value = recv.getString(key, def_value);
+ return_value = self.getString(key, def_value);
} catch (ClassCastException e) {
return def_value;
}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeSharedPreferences_sys(recv);
+ Sys sys = NativeSharedPreferences_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
extern class NativeSharedPreferencesEditor in "Java" `{ android.content.SharedPreferences$Editor `}
super JavaObject
- fun clear: NativeSharedPreferencesEditor in "Java" `{ return recv.clear(); `}
- fun commit: Bool in "Java" `{ return recv.commit(); `}
- fun put_boolean(key: JavaString, value: Bool ): NativeSharedPreferencesEditor in "Java" `{
- return recv.putBoolean (key, value);
+ fun clear: NativeSharedPreferencesEditor in "Java" `{ return self.clear(); `}
+ fun commit: Bool in "Java" `{ return self.commit(); `}
+ fun put_boolean(key: JavaString, value: Bool): NativeSharedPreferencesEditor in "Java" `{
+ return self.putBoolean (key, value);
`}
fun put_float(key: JavaString, value: Float): NativeSharedPreferencesEditor in "Java" `{
- return recv.putFloat(key, (float) value);
+ return self.putFloat(key, (float) value);
`}
fun put_int(key: JavaString, value: Int): NativeSharedPreferencesEditor in "Java" `{
- return recv.putInt(key, (int)value);
+ return self.putInt(key, (int)value);
`}
fun put_long(key: JavaString, value: Int): NativeSharedPreferencesEditor in "Java" `{
- return recv.putLong(key, value);
+ return self.putLong(key, value);
`}
fun put_string(key: JavaString, value: JavaString): NativeSharedPreferencesEditor in "Java" `{
- return recv.putString(key, value);
+ return self.putString(key, value);
`}
- fun remove(key: JavaString): NativeSharedPreferencesEditor in "Java" `{
- return recv.remove(key);
+ fun remove(key: JavaString): NativeSharedPreferencesEditor in "Java" `{
+ return self.remove(key);
`}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = NativeSharedPreferencesEditor_sys(recv);
+ Sys sys = NativeSharedPreferencesEditor_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
# Automatically commits every saving/removing instructions (`true` by default)
var auto_commit = true
-
- protected init(app: App, file_name: String, mode: Int)
+
+ protected init(app: App, file_name: String, mode: Int)
do
self.context = app.native_activity
sys.jni_env.push_local_frame(1)
end
# Restricts file access to the current application
- init privately(app: App, file_name: String)
+ init privately(app: App, file_name: String)
do
self.init(app, file_name, private_mode)
end
end
private fun setup(file_name: JavaString, mode: Int) import context, set_vars in "Java" `{
- Activity context = (Activity) SharedPreferences_context(recv);
+ Activity context = (Activity) SharedPreferences_context(self);
SharedPreferences sp;
// Uses default SharedPreferences if file_name is an empty String
if (file_name.equals("")) {
sp = context.getPreferences((int)mode);
- } else {
+ } else {
sp = context.getSharedPreferences(file_name, (int)mode);
}
SharedPreferences.Editor editor = sp.edit();
-
- SharedPreferences_set_vars(recv, sp, editor);
+
+ SharedPreferences_set_vars(self, sp, editor);
`}
private fun commit_if_auto do if auto_commit then self.commit
# Returns true if there's an entry corresponding the given key
- fun has(key: String): Bool
+ fun has(key: String): Bool
do
sys.jni_env.push_local_frame(2)
- var return_value = shared_preferences.contains(key.to_java_string)
+ var return_value = shared_preferences.contains(key.to_java_string)
sys.jni_env.pop_local_frame
return return_value
end
# var foo = new HashMap[JavaString, JavaObject]
# # ...
# for key, value in foo do
- # key.delete_local_ref
- # value.delete_local_ref
+ # key.delete_local_ref
+ # value.delete_local_ref
# end
# ~~~
- # *You should use Nit getters instead and get each value one by one*
+ # *You should use Nit getters instead and get each value one by one*
fun all: nullable HashMap[JavaString, JavaObject]
- do
+ do
var hashmap = shared_preferences.get_all
if hashmap.is_empty then return null
return hashmap
# Returns the `Bool` value corresponding the given key or `def_value` if none
# or if the value isn't of correct type
- fun bool(key: String, def_value: Bool): Bool
- do
+ fun bool(key: String, def_value: Bool): Bool
+ do
sys.jni_env.push_local_frame(2)
var return_value = shared_preferences.get_boolean(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
# Returns the `Float` value corresponding the given key or `def_value` if none
# or if the value isn't of correct type
- fun float(key: String, def_value: Float): Float
- do
+ fun float(key: String, def_value: Float): Float
+ do
sys.jni_env.push_local_frame(2)
var return_value = shared_preferences.get_float(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
# Returns the `Int` value corresponding the given key or `def_value` if none
# or if the value isn't of correct type
- # Be aware of possible `def_value` integer overflow as the Nit `Int` corresponds
+ # Be aware of possible `def_value` integer overflow as the Nit `Int` corresponds
# to Java `long`
- fun int(key: String, def_value: Int): Int
- do
+ fun int(key: String, def_value: Int): Int
+ do
sys.jni_env.push_local_frame(2)
var return_value = shared_preferences.get_int(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
# or if the value isn't of correct type
# Calls `getLong(key, value)` java method
# Nit `Int` is equivalent to Java `long` so that no integer overflow will occur
- fun long(key: String, def_value: Int): Int
- do
+ fun long(key: String, def_value: Int): Int
+ do
sys.jni_env.push_local_frame(2)
var return_value = shared_preferences.get_long(key.to_java_string, def_value)
sys.jni_env.pop_local_frame
# Returns the `String` value corresponding the given key or `def_value` if none
# or if the value isn't of correct type
- fun string(key: String, def_value: String): String
- do
+ fun string(key: String, def_value: String): String
+ do
sys.jni_env.push_local_frame(3)
- var java_return_value = shared_preferences.get_string(key.to_java_string,
+ var java_return_value = shared_preferences.get_string(key.to_java_string,
def_value.to_java_string)
var nit_return_value = java_return_value.to_s
sys.jni_env.pop_local_frame
return nit_return_value
end
- # Clears all the dictionnary entries in the specified file or the default file
+ # Clears all the dictionnary entries in the specified file or the default file
# if none specified at instanciation
# Returns `self` allowing fluent programming
- fun clear: SharedPreferences
- do
+ fun clear: SharedPreferences
+ do
editor.clear
commit_if_auto
return self
end
-
+
# If auto_commit is `false`, has to be called to save the data to persistant memory
- fun commit: Bool
- do
+ fun commit: Bool
+ do
sys.jni_env.push_local_frame(1)
var return_value = editor.commit
sys.jni_env.pop_local_frame
# Set a key-value pair using a `Bool` value
# Returns `self` allowing fluent programming
- fun add_bool(key: String, value: Bool ): SharedPreferences
- do
+ fun add_bool(key: String, value: Bool): SharedPreferences
+ do
sys.jni_env.push_local_frame(1)
editor.put_boolean(key.to_java_string, value)
sys.jni_env.pop_local_frame
#
# Be aware of possible loss of precision as Nit `Float` corresponds to Java `double`
# and the methods stores a Java `float`
- fun add_float(key: String, value: Float): SharedPreferences
- do
+ fun add_float(key: String, value: Float): SharedPreferences
+ do
sys.jni_env.push_local_frame(1)
editor.put_float(key.to_java_string, value)
sys.jni_env.pop_local_frame
# Be aware of possible integer overflow as the Nit `Int` corresponds to Java `long`
# and the methods stores a Java `int`
# *You might want to use add_long instead*
- fun add_int(key: String, value: Int): SharedPreferences
- do
+ fun add_int(key: String, value: Int): SharedPreferences
+ do
sys.jni_env.push_local_frame(1)
editor.put_int(key.to_java_string, value)
sys.jni_env.pop_local_frame
# Set a key-value pair using a `Int` type value
# Returns `self` allowing fluent programming
- fun add_long(key: String, value: Int): SharedPreferences
- do
+ fun add_long(key: String, value: Int): SharedPreferences
+ do
sys.jni_env.push_local_frame(1)
editor.put_long(key.to_java_string, value)
sys.jni_env.pop_local_frame
# Set a key-value pair using a `String` type value
# Returns `self` allowing fluent programming
- fun add_string(key: String, value: String): SharedPreferences
- do
+ fun add_string(key: String, value: String): SharedPreferences
+ do
sys.jni_env.push_local_frame(2)
editor.put_string(key.to_java_string, value.to_java_string)
sys.jni_env.pop_local_frame
# Removes the corresponding entry in the file
# Returns `self` allowing fluent programming
- fun remove(key: String): SharedPreferences
- do
+ fun remove(key: String): SharedPreferences
+ do
sys.jni_env.push_local_frame(1)
editor.remove(key.to_java_string)
sys.jni_env.pop_local_frame
end
# Deallocate global references allocated by the SharedPreferences instance
- fun destroy
+ fun destroy
do
self.shared_preferences.delete_global_ref
self.editor.delete_global_ref
import shared_preferences
-in "Java" `{
+in "Java" `{
import java.util.HashSet;
- import java.util.Set;
- import android.content.Context;
+ import java.util.Set;
+ import android.content.Context;
`}
redef extern class NativeSharedPreferences
-
+
# Default value to null instead of Set<String>
- fun get_string_set(key: JavaString): HashSet[JavaString] import HashSet[JavaString],
- HashSet[JavaString].add in "Java" `{
+ fun get_string_set(key: JavaString): HashSet[JavaString] import HashSet[JavaString],
+ HashSet[JavaString].add in "Java" `{
Set<String> def_value = new HashSet<String>();
- Set<String> java_set = recv.getStringSet(key, def_value);
+ Set<String> java_set = self.getStringSet(key, def_value);
int nit_hashset = new_HashSet_of_JavaString();
for (String element: java_set)
`}
end
-redef extern class NativeSharedPreferencesEditor
-
- fun put_string_set(key: JavaString, value: HashSet[JavaString]): NativeSharedPreferencesEditor
- import HashSet[JavaString], HashSet[JavaString].iterator, Iterator[JavaString].is_ok,
- Iterator[JavaString].item, Iterator[JavaString].next in "Java" `{
+redef extern class NativeSharedPreferencesEditor
+
+ fun put_string_set(key: JavaString, value: HashSet[JavaString]): NativeSharedPreferencesEditor
+ import HashSet[JavaString], HashSet[JavaString].iterator, Iterator[JavaString].is_ok,
+ Iterator[JavaString].item, Iterator[JavaString].next in "Java" `{
Set<String> java_set = new HashSet<String>();
int itr = HashSet_of_JavaString_iterator(value);
-
+
while (Iterator_of_JavaString_is_ok(itr)) {
java_set.add(Iterator_of_JavaString_item(itr));
Iterator_of_JavaString_next(itr);
}
- return recv.putStringSet(key, java_set);
+ return self.putStringSet(key, java_set);
`}
end
-
+
redef class SharedPreferences
# Allows multiple processes to write into the same `SharedPreferences` file
# # ...
# for element in a_hash_set do element.delete_local_ref
# ~~~
- fun string_set(key: String): HashSet[JavaString]
- do
+ fun string_set(key: String): HashSet[JavaString]
+ do
sys.jni_env.push_local_frame(3)
var return_value = shared_preferences.get_string_set(key.to_java_string)
sys.jni_env.pop_local_frame
# for element in foo do element.delete_local_ref
# ~~~
fun add_string_set(key: String, value: HashSet[JavaString]): SharedPreferences
- do
+ do
editor.put_string_set(key.to_java_string, value)
return self
end
private fun native_toast(message: JavaString, is_long: Bool)
import native_activity in "Java" `{
- final android.app.Activity context = App_native_activity(recv);
+ final android.app.Activity context = App_native_activity(self);
final CharSequence final_message = message;
final int duration = is_long? Toast.LENGTH_LONG: Toast.LENGTH_SHORT;
# Set the main layout of this activity
fun content_view=(layout: NativeViewGroup) in "Java" `{
final ViewGroup final_layout = layout;
- final Activity final_recv = recv;
+ final Activity final_self = self;
- recv.runOnUiThread(new Runnable() {
+ self.runOnUiThread(new Runnable() {
@Override
public void run() {
- final_recv.setContentView(final_layout);
+ final_self.setContentView(final_layout);
final_layout.requestFocus();
}
extern class NativeView in "Java" `{ android.view.View `}
super JavaObject
- fun minimum_width=(val: Int) in "Java" `{ recv.setMinimumWidth((int)val); `}
- fun minimum_height=(val: Int) in "Java" `{ recv.setMinimumHeight((int)val); `}
+ fun minimum_width=(val: Int) in "Java" `{ self.setMinimumWidth((int)val); `}
+ fun minimum_height=(val: Int) in "Java" `{ self.setMinimumHeight((int)val); `}
- fun enabled: Bool in "Java" `{ return recv.isEnabled(); `}
+ fun enabled: Bool in "Java" `{ return self.isEnabled(); `}
fun enabled=(value: Bool) in "Java" `{
- final View final_recv = recv;
+ final View final_self = self;
final boolean final_value = value;
- ((Activity)recv.getContext()).runOnUiThread(new Runnable() {
+ ((Activity)self.getContext()).runOnUiThread(new Runnable() {
@Override
public void run() {
- final_recv.setEnabled(final_value);
+ final_self.setEnabled(final_value);
}
});
`}
extern class NativeViewGroup in "Java" `{ android.view.ViewGroup `}
super NativeView
- fun add_view(view: NativeView) in "Java" `{ recv.addView(view); `}
+ fun add_view(view: NativeView) in "Java" `{ self.addView(view); `}
fun add_view_with_weight(view: NativeView, weight: Float)
in "Java" `{
- recv.addView(view, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT, (float)weight));
+ self.addView(view, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT, (float)weight));
`}
end
new(context: NativeActivity) in "Java" `{ return new LinearLayout(context); `}
- fun set_vertical in "Java" `{ recv.setOrientation(LinearLayout.VERTICAL); `}
- fun set_horizontal in "Java" `{ recv.setOrientation(LinearLayout.HORIZONTAL); `}
+ fun set_vertical in "Java" `{ self.setOrientation(LinearLayout.VERTICAL); `}
+ fun set_horizontal in "Java" `{ self.setOrientation(LinearLayout.HORIZONTAL); `}
redef fun add_view(view) in "Java"
`{
MarginLayoutParams params = new MarginLayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.WRAP_CONTENT);
- recv.addView(view, params);
+ self.addView(view, params);
`}
end
new(context: NativeActivity) in "Java" `{ return new android.widget.GridLayout(context); `}
- fun row_count=(val: Int) in "Java" `{ recv.setRowCount((int)val); `}
+ fun row_count=(val: Int) in "Java" `{ self.setRowCount((int)val); `}
- fun column_count=(val: Int) in "Java" `{ recv.setColumnCount((int)val); `}
+ fun column_count=(val: Int) in "Java" `{ self.setColumnCount((int)val); `}
- redef fun add_view(view) in "Java" `{ recv.addView(view); `}
+ redef fun add_view(view) in "Java" `{ self.addView(view); `}
end
extern class NativePopupWindow in "Java" `{ android.widget.PopupWindow `}
super NativeView
new (context: NativeActivity) in "Java" `{
- PopupWindow recv = new PopupWindow(context);
- recv.setWindowLayoutMode(LinearLayout.LayoutParams.MATCH_PARENT,
+ PopupWindow self = new PopupWindow(context);
+ self.setWindowLayoutMode(LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.MATCH_PARENT);
- recv.setClippingEnabled(false);
- return recv;
+ self.setClippingEnabled(false);
+ return self;
`}
- fun content_view=(layout: NativeViewGroup) in "Java" `{ recv.setContentView(layout); `}
+ fun content_view=(layout: NativeViewGroup) in "Java" `{ self.setContentView(layout); `}
end
extern class NativeTextView in "Java" `{ android.widget.TextView `}
new (context: NativeActivity) in "Java" `{ return new TextView(context); `}
- fun text: JavaString in "Java" `{ return recv.getText().toString(); `}
+ fun text: JavaString in "Java" `{ return self.getText().toString(); `}
fun text=(value: JavaString) in "Java" `{
- final TextView final_recv = recv;
+ final TextView final_self = self;
final String final_value = value;
- ((Activity)recv.getContext()).runOnUiThread(new Runnable() {
+ ((Activity)self.getContext()).runOnUiThread(new Runnable() {
@Override
public void run() {
- final_recv.setText(final_value);
+ final_self.setText(final_value);
}
});
`}
fun gravity_center in "Java" `{
- recv.setGravity(Gravity.CENTER);
+ self.setGravity(Gravity.CENTER);
`}
fun text_size: Float in "Java" `{
- return recv.getTextSize();
+ return self.getTextSize();
`}
fun text_size=(dpi: Float) in "Java" `{
- recv.setTextSize(android.util.TypedValue.COMPLEX_UNIT_DIP, (float)dpi);
+ self.setTextSize(android.util.TypedValue.COMPLEX_UNIT_DIP, (float)dpi);
`}
end
new (context: NativeActivity) in "Java" `{ return new android.widget.EditText(context); `}
- fun width=(val: Int) in "Java" `{ recv.setWidth((int)val); `}
+ fun width=(val: Int) in "Java" `{ self.setWidth((int)val); `}
- fun input_type_text in "Java" `{ recv.setInputType(android.text.InputType.TYPE_CLASS_TEXT); `}
+ fun input_type_text in "Java" `{ self.setInputType(android.text.InputType.TYPE_CLASS_TEXT); `}
redef fun new_global_ref: SELF import sys, Sys.jni_env `{
- Sys sys = NativeEditText_sys(recv);
+ Sys sys = NativeEditText_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
redef type SELF: NativeButton
redef fun new_global_ref: SELF import sys, Sys.jni_env `{
- Sys sys = NativeButton_sys(recv);
+ Sys sys = NativeButton_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
super JavaObject
# Vibrate for `n` miliseconds
- fun vibrate(n: Int) in "Java" `{ recv.vibrate(n); `}
+ fun vibrate(n: Int) in "Java" `{ self.vibrate(n); `}
# Does this devices has a vibrator
#
# TODO activate in API 11
- #fun exists: Bool in "Java" `{ return recv.hasVibrator(); `}
+ #fun exists: Bool in "Java" `{ return self.hasVibrator(); `}
# Turn off the vibration
- fun cancel in "Java" `{ recv.cancel(); `}
+ fun cancel in "Java" `{ self.cancel(); `}
# HACK for bug #845
redef fun new_global_ref import sys, Sys.jni_env `{
- Sys sys = Vibrator_sys(recv);
+ Sys sys = Vibrator_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
end
new p1_26 `{ return RPI_GPIO_P1_26; `}
# Select mode: input, output or alts
- fun fsel=(mode: FunctionSelect) `{ bcm2835_gpio_fsel(recv, mode); `}
+ fun fsel=(mode: FunctionSelect) `{ bcm2835_gpio_fsel(self, mode); `}
# Set output
- redef fun write(high) `{ bcm2835_gpio_write(recv, high? HIGH: LOW); `}
+ redef fun write(high) `{ bcm2835_gpio_write(self, high? HIGH: LOW); `}
# Set pull up mode
- fun pud=(pud: PUDControl) `{ bcm2835_gpio_set_pud(recv, pud); `}
+ fun pud=(pud: PUDControl) `{ bcm2835_gpio_set_pud(self, pud); `}
# Falling edge detect
# Do not use on raspbian, it is bugged!
- fun fen `{ bcm2835_gpio_fen(recv); `}
- fun clr_fen `{ bcm2835_gpio_clr_fen(recv); `}
+ fun fen `{ bcm2835_gpio_fen(self); `}
+ fun clr_fen `{ bcm2835_gpio_clr_fen(self); `}
# Raising edge detect
# Do not use on raspbian, it is bugged!
- fun ren `{ bcm2835_gpio_ren(recv); `}
- fun clr_ren `{ bcm2835_gpio_clr_ren(recv); `}
+ fun ren `{ bcm2835_gpio_ren(self); `}
+ fun clr_ren `{ bcm2835_gpio_clr_ren(self); `}
# High edge detect
# Do not use on raspbian, it is bugged!
- fun hen `{ bcm2835_gpio_hen(recv); `}
- fun clr_hen `{ bcm2835_gpio_clr_hen(recv); `}
+ fun hen `{ bcm2835_gpio_hen(self); `}
+ fun clr_hen `{ bcm2835_gpio_clr_hen(self); `}
# Low edge detect
# Do not use on raspbian, it is bugged!
- fun len `{ bcm2835_gpio_len(recv); `}
- fun clr_len `{ bcm2835_gpio_clr_len(recv); `}
+ fun len `{ bcm2835_gpio_len(self); `}
+ fun clr_len `{ bcm2835_gpio_clr_len(self); `}
- fun set_eds `{ bcm2835_gpio_set_eds(recv); `}
- fun eds: Bool `{ return bcm2835_gpio_eds(recv); `}
+ fun set_eds `{ bcm2835_gpio_set_eds(self); `}
+ fun eds: Bool `{ return bcm2835_gpio_eds(self); `}
# Return input on pin, true for high and false for low
- fun lev: Bool `{ return bcm2835_gpio_lev(recv); `}
+ fun lev: Bool `{ return bcm2835_gpio_lev(self); `}
end
extern class FunctionSelect `{ bcm2835FunctionSelect `}
end
redef universal Int
- fun bcm2835_delay `{ bcm2835_delay(recv); `}
- fun bcm2835_delay_micros `{ bcm2835_delayMicroseconds(recv); `}
+ fun bcm2835_delay `{ bcm2835_delay(self); `}
+ fun bcm2835_delay_micros `{ bcm2835_delayMicroseconds(self); `}
end
class RotaryEncoder
write_byte int
end
+ # Write `text` as a null terminated string
+ #
+ # To be used with `Reader::read_string`.
+ #
+ # Require: `text` has no null bytes.
+ fun write_string(text: Text)
+ do
+ write text
+ write_byte 0x00
+ end
+
+ # Write the length as a 64 bits integer, then the content of `text`
+ #
+ # To be used with `Reader::read_block`.
+ #
+ # Compared to `write_string`, this method supports null bytes in `text`.
+ fun write_block(text: Text)
+ do
+ write_int64 text.length
+ write text
+ end
+
# Write a floating point `value` on 32 bits
#
# Using this format may result in a loss of precision as it uses less bits
return [for b in 8.times do int.bin_and(2**b) > 0]
end
+ # Read a null terminated string
+ #
+ # To be used with `Writer::write_string`.
+ fun read_string: String
+ do
+ var buf = new FlatBuffer
+ loop
+ var byte = read_byte
+ if byte == 0x00 then return buf.to_s
+ buf.chars.add byte.ascii
+ end
+ end
+
+ # Read the length as a 64 bits integer, then the content of the block
+ #
+ # To be used with `Writer::write_block`.
+ fun read_block: String
+ do
+ var length = read_int64
+ if length == 0 then return ""
+ return read(length)
+ end
+
# Read a floating point on 32 bits and return it as a `Float`
#
# Using this format may result in a loss of precision as it uses less bits
uint64_t conv;
} u;
- u.val = recv;
+ u.val = self;
if (big_endian)
u.conv = htobe64(u.conv);
uint32_t conv;
} u;
- u.val = recv;
+ u.val = self;
if (big_endian)
u.conv = htobe32(u.conv);
uint64_t conv;
} u;
- u.val = recv;
+ u.val = self;
if (big_endian)
u.conv = htobe64(u.conv);
# =============== Bitmap header ================
for x in [0..13] do
- bitmap_header[x] = fileReader.read(1)[0].ascii
+ var b = fileReader.read_byte
+ if b == null then
+ return
+ end
+ bitmap_header[x] = b
end
self.file_size = get_value(bitmap_header.subarray(2, 4))
self.data_offset = get_value(bitmap_header.subarray(10, 4))
# =============== DIB header ================
for x in [0..39] do
- dib_header[x] = fileReader.read(1)[0].ascii
+ var b = fileReader.read_byte
+ if b == null then return
+ dib_header[x] = b
end
var dib_size = get_value(dib_header.subarray(0, 4))
# only support BITMAPINFOHEADER
var row = new Array[Int].with_capacity(self.width)
for y in [0..self.width[
do
- var red = fileReader.read(1)[0].ascii * 256 * 256
- var green = fileReader.read(1)[0].ascii * 256
- var blue = fileReader.read(1)[0].ascii
+ var bts = fileReader.read_bytes(3)
+ if bts.length != 3 then return
+ var red = bts[0] << 16
+ var green = bts[1] << 8
+ var blue = bts[2]
row.add(red + green + blue)
end
self.data.add(row)
fileReader.close
end #end of load_from_file method
- # Reads in a series of bytes from the FileReader when loading a Bitmap from a file
- # FileReader.read(1) is used due to https://github.com/privat/nit/issues/1264
- private fun read_chars(fr: FileReader, howMany: Int): String
- do
- var s = ""
- for x in [1..howMany]
- do
- s += fr.read(1)
- end
- return s
- end
-
# Converts the value contained in two or four bytes into an Int. Since Nit
# does not have a byte type, Int is used
private fun get_value(array: Array[Int]): Int
# Initialize a new NativeCIntArray of `size` elements.
new(size: Int) `{ return calloc(size, sizeof(int)); `}
- redef fun [](index) `{ return recv[index]; `}
- redef fun []=(index, val) `{ recv[index] = val; `}
+ redef fun [](index) `{ return self[index]; `}
+ redef fun []=(index, val) `{ self[index] = val; `}
- redef fun +(offset) `{ return recv + offset; `}
+ redef fun +(offset) `{ return self + offset; `}
end
# Wrapper around an array of `unsigned char` in C (`unsigned char*`) with length and destroy state
# Allocate a new array of `size`
new(size: Int) `{ return calloc(size, sizeof(unsigned char)); `}
- redef fun [](index) `{ return recv[index]; `}
- redef fun []=(index, val) `{ recv[index] = val; `}
+ redef fun [](index) `{ return self[index]; `}
+ redef fun []=(index, val) `{ self[index] = val; `}
- redef fun +(offset) `{ return recv + offset; `}
+ redef fun +(offset) `{ return self + offset; `}
end
# Wrapper around an array of `NativeString` in C (`char**`) with length and destroy state.
# Initialize a new NativeCStringArray of `size` elements.
new(size: Int) `{ return calloc(size, sizeof(char*)); `}
- redef fun [](index) `{ return recv[index]; `}
- redef fun []=(index, val) `{ recv[index] = val; `}
- redef fun +(offset) `{ return recv + offset; `}
+ redef fun [](index) `{ return self[index]; `}
+ redef fun []=(index, val) `{ self[index] = val; `}
+ redef fun +(offset) `{ return self + offset; `}
end
redef class NativeString
super NativeCArray
redef type E: Char
- redef fun +(offset) `{ return recv + offset; `}
+ redef fun +(offset) `{ return self + offset; `}
end
new in "ObjC" `{ return [[NSAlert alloc] init]; `}
# Set the content of this message box
- fun message_text=(text: NSString) in "ObjC" `{ [recv setMessageText:text]; `}
+ fun message_text=(text: NSString) in "ObjC" `{ [self setMessageText:text]; `}
# Show this message box
- fun run_modal in "ObjC" `{ [recv runModal]; `}
+ fun run_modal in "ObjC" `{ [self runModal]; `}
end
redef class NativeString
# Get a `NSString` from `self` with the specified `length`
fun to_nsstring(length: Int): NSString in "ObjC" `{
- return [[NSString alloc] initWithBytes:recv
+ return [[NSString alloc] initWithBytes:self
length:length
encoding:NSASCIIStringEncoding];
`}
redef class NativeString
# Get `self` as a `CppString`
fun to_cpp_string(length: Int): CppString in "C++" `{
- return new std::string(recv, length);
+ return new std::string(self, length);
`}
end
var status_code = 0
# Receive body from request due to body callback registering
- redef fun body_callback(line: String)
- do
+ redef fun body_callback(line) do
self.body_str = "{self.body_str}{line}"
end
end
# Constructor, CURL low level initializer
new easy_init `{ return curl_easy_init(); `}
# Check for correct initialization
- fun is_init:Bool `{ return (recv != NULL); `}
+ fun is_init:Bool `{ return (self != NULL); `}
# Easy Clean / Release CURL instance
- fun easy_clean `{ curl_easy_cleanup( recv ); `}
+ fun easy_clean `{ curl_easy_cleanup( self ); `}
# Perform the transfer described by setted options
- fun easy_perform:CURLCode `{ return curl_easy_perform( recv ); `}
+ fun easy_perform:CURLCode `{ return curl_easy_perform( self ); `}
# Set options to tell CURL how to behave. Obj parameter type can be Int, Bool, String, OFile, CURLSList.
fun easy_setopt(opt: CURLOption, obj: Object):CURLCode
do
return once new CURLCode.unknown_option
end
# Internal method to set options to CURL using OFile parameter.
- private fun i_setopt_file(opt: CURLOption, fl: OFile):CURLCode `{ return curl_easy_setopt( recv, opt, fl); `}
+ private fun i_setopt_file(opt: CURLOption, fl: OFile):CURLCode `{ return curl_easy_setopt( self, opt, fl); `}
# Internal method to set options to CURL using Int parameter.
- private fun i_setopt_int(opt: CURLOption, num: Int):CURLCode `{ return curl_easy_setopt( recv, opt, num); `}
+ private fun i_setopt_int(opt: CURLOption, num: Int):CURLCode `{ return curl_easy_setopt( self, opt, num); `}
# Internal method to set options to CURL using CURLSList parameter.
- private fun i_setopt_slist(opt: CURLOption, list: CURLSList):CURLCode `{ return curl_easy_setopt( recv, opt, list); `}
+ private fun i_setopt_slist(opt: CURLOption, list: CURLSList):CURLCode `{ return curl_easy_setopt( self, opt, list); `}
# Internal method to set options to CURL using String parameter.
private fun i_setopt_string(opt: CURLOption, str: String):CURLCode import String.to_cstring `{
char *rStr = String_to_cstring(str);
- return curl_easy_setopt( recv, opt, rStr);
+ return curl_easy_setopt( self, opt, rStr);
`}
# Request Chars internal information from the CURL session
fun easy_getinfo_chars(opt: CURLInfoChars):nullable CURLInfoResponseString
# Internal method used to get String object information initially knowns as C Chars type
private fun i_getinfo_chars(opt: CURLInfoChars, res: CURLInfoResponseString):CURLCode import CURLInfoResponseString.response=, NativeString.to_s_with_copy `{
char *r = NULL;
- CURLcode c = curl_easy_getinfo( recv, opt, &r);
+ CURLcode c = curl_easy_getinfo( self, opt, &r);
if((c == CURLE_OK) && r != NULL){
String ro = NativeString_to_s_with_copy(r);
CURLInfoResponseString_response__assign( res, ro);
private fun i_getinfo_long(opt: CURLInfoLong, res: CURLInfoResponseLong):CURLCode import CURLInfoResponseLong.response= `{
long *r = NULL;
r = malloc(sizeof(long));
- CURLcode c = curl_easy_getinfo( recv, opt, r);
+ CURLcode c = curl_easy_getinfo( self, opt, r);
if((c == CURLE_OK) && r != NULL) CURLInfoResponseLong_response__assign( res, *r);
free(r);
return c;
private fun i_getinfo_double(opt: CURLInfoDouble, res: CURLInfoResponseDouble):CURLCode import CURLInfoResponseDouble.response= `{
double *r = NULL;
r = malloc(sizeof(double));
- CURLcode c = curl_easy_getinfo( recv, opt, r);
+ CURLcode c = curl_easy_getinfo( self, opt, r);
if((c == CURLE_OK) && r != NULL) CURLInfoResponseDouble_response__assign( res, *r);
free(r);
return c;
# Internal method used to get Array[String] object information initially knowns as C SList type
private fun i_getinfo_slist(opt: CURLInfoSList, res: CURLInfoResponseArray):CURLCode import CURLInfoResponseArray.prim_response=`{
struct curl_slist* csl = NULL;
- CURLcode ce = curl_easy_getinfo( recv, opt, &csl);
+ CURLcode ce = curl_easy_getinfo( self, opt, &csl);
CURLInfoResponseArray_prim_response__assign(res, csl);
return ce;
`}
d->data = (char*)String_to_cstring(datas);
d->len = size;
d->pos = 0;
- return curl_easy_setopt( recv, CURLOPT_READDATA, d);
+ return curl_easy_setopt( self, CURLOPT_READDATA, d);
`}
# Internal method used to configure callbacks in terms of given type
private fun i_register_callback(delegate: CCurlCallbacks, cbtype: CURLCallbackType):CURLCode is extern import CCurlCallbacks.header_callback, CCurlCallbacks.body_callback, CCurlCallbacks.stream_callback, NativeString.to_s_with_copy, NativeString.to_s `{
CURLcode e;
switch(cbtype){
case CURLcallbackTypeHeader:
- e = curl_easy_setopt( recv, CURLOPT_HEADERFUNCTION, (curl_write_callback)&nit_curl_callback_func);
+ e = curl_easy_setopt( self, CURLOPT_HEADERFUNCTION, (curl_write_callback)&nit_curl_callback_func);
if(e != CURLE_OK) return e;
- e = curl_easy_setopt( recv, CURLOPT_WRITEHEADER, d);
+ e = curl_easy_setopt( self, CURLOPT_WRITEHEADER, d);
break;
case CURLcallbackTypeBody:
case CURLcallbackTypeStream:
- e = curl_easy_setopt( recv, CURLOPT_WRITEFUNCTION, (curl_write_callback)&nit_curl_callback_func);
+ e = curl_easy_setopt( self, CURLOPT_WRITEFUNCTION, (curl_write_callback)&nit_curl_callback_func);
if(e != CURLE_OK) return e;
- e = curl_easy_setopt( recv, CURLOPT_WRITEDATA, d);
+ e = curl_easy_setopt( self, CURLOPT_WRITEDATA, d);
break;
case CURLcallbackTypeRead:
- e = curl_easy_setopt( recv, CURLOPT_READFUNCTION, (curl_write_callback)&nit_curl_callback_read_func);
+ e = curl_easy_setopt( self, CURLOPT_READFUNCTION, (curl_write_callback)&nit_curl_callback_read_func);
default:
break;
}
fun escape(url: String):String import String.to_cstring, NativeString.to_s_with_copy `{
char *orig_url, *encoded_url = NULL;
orig_url = String_to_cstring(url);
- encoded_url = curl_easy_escape( recv, orig_url, strlen(orig_url));
+ encoded_url = curl_easy_escape( self, orig_url, strlen(orig_url));
String b_url = NativeString_to_s_with_copy(encoded_url);
curl_free(encoded_url);
return b_url;
# Open / Create a file from given name
new open(str: NativeString) `{ return fopen(str, "wb"); `}
# Check for File validity
- fun is_valid:Bool `{ return recv != NULL; `}
+ fun is_valid:Bool `{ return self != NULL; `}
# Internal method to write to the current file
- private fun n_write(buffer: NativeString, size: Int, count: Int):Int `{ return fwrite(buffer, size, count, recv); `}
+ private fun n_write(buffer: NativeString, size: Int, count: Int):Int `{ return fwrite(buffer, size, count, self); `}
# Write datas to the current file
fun write(buffer: String, size: Int, count: Int):Int
do
return 0
end
# Internal method to close the current file
- private fun n_close:Int `{ return fclose(recv); `}
+ private fun n_close:Int `{ return fclose(self); `}
# Close the current file
fun close:Bool
do
new body `{ return CURLcallbackTypeBody; `}
new stream `{ return CURLcallbackTypeStream; `}
new read `{ return CURLcallbackTypeRead; `}
- fun to_i:Int `{ return recv; `}
+ fun to_i:Int `{ return self; `}
end
# CURL Code binding and helpers
new unsupported_protocol `{ return CURLE_UNSUPPORTED_PROTOCOL; `}
new ok `{ return CURLE_OK; `}
new failed_init `{ return CURLE_FAILED_INIT; `}
- fun code:Int `{ return recv; `}
- fun is_ok:Bool `{ return recv == CURLE_OK; `}
- fun is_valid_protocol:Bool `{ return recv == CURLE_UNSUPPORTED_PROTOCOL; `}
- fun is_valid_init:Bool `{ return recv == CURLE_FAILED_INIT; `}
+ fun code:Int `{ return self; `}
+ fun is_ok:Bool `{ return self == CURLE_OK; `}
+ fun is_valid_protocol:Bool `{ return self == CURLE_UNSUPPORTED_PROTOCOL; `}
+ fun is_valid_init:Bool `{ return self == CURLE_FAILED_INIT; `}
fun to_i:Int do return code end
redef fun to_s import NativeString.to_s_with_copy `{
- char *c = (char*)curl_easy_strerror(recv);
+ char *c = (char*)curl_easy_strerror(self);
return NativeString_to_s_with_copy(c);
`}
end
return l;
`}
# Check for initialization
- fun is_init:Bool `{ return (recv != NULL); `}
+ fun is_init:Bool `{ return (self != NULL); `}
# Append an element in the linked list
fun append(key: String) import String.to_cstring `{
char *k = String_to_cstring(key);
- curl_slist_append(recv, (char*)k);
+ curl_slist_append(self, (char*)k);
`}
# Internal method to check for reachability of current data
private fun i_data_reachable(c: CURLSList):Bool `{ return (c != NULL && c->data != NULL); `}
return r
end
# Release allocated memory
- fun destroy `{ curl_slist_free_all(recv); `}
+ fun destroy `{ curl_slist_free_all(self); `}
end
redef class Collection[E]
new condition_unmet `{ return CURLINFO_CONDITION_UNMET; `}
new rtsp_client_cseq `{ return CURLINFO_RTSP_CLIENT_CSEQ; `}
new rtsp_server_cseq `{ return CURLINFO_RTSP_SERVER_CSEQ; `}
- new rtsp_cseq_recv `{ return CURLINFO_RTSP_CSEQ_RECV; `}
+ new rtsp_cseq_self `{ return CURLINFO_RTSP_CSEQ_RECV; `}
end
# Reproduce Enum of available CURL Double information, used for CCurl.easy_getinfo
new service_unavailable `{ return 503; `}
new gateway_timeout `{ return 504; `}
new http_version_not_supported `{ return 505; `}
- fun to_i:Int `{ return recv; `}
+ fun to_i:Int `{ return self; `}
end
# Reproduce Enum of CURL Options usable, used for CCurl.easy_setopt
fun destroy do self.curl.destroy
# Header callback
- redef fun header_callback(line: String) do
+ redef fun header_callback(line) do
# We keep this callback silent for testing purposes
#if not line.has_prefix("Date:") then print "Header_callback : {line}"
end
# Body callback
- redef fun body_callback(line: String) do self.our_body = "{self.our_body}{line}"
+ redef fun body_callback(line) do self.our_body = "{self.our_body}{line}"
# Stream callback - Cf : No one is registered
- redef fun stream_callback(buffer: String, size: Int, count: Int) do print "Stream_callback : {buffer} - {size} - {count}"
+ redef fun stream_callback(buffer, size, count) do print "Stream_callback : {buffer} - {size} - {count}"
end
# Clear the entire window so it can be repainted from scratch with a refresh
fun wclear `{
- wclear(recv);
+ wclear(self);
`}
# Delete the window
fun delwin `{
- delwin(recv);
+ delwin(self);
`}
# Suspend the curses session and restore the previous terminal
new current `{ return eglGetCurrentDisplay(); `}
new(handle: Pointer) `{ return eglGetDisplay(handle); `}
- fun is_valid: Bool `{ return recv != EGL_NO_DISPLAY; `}
+ fun is_valid: Bool `{ return self != EGL_NO_DISPLAY; `}
fun initialize: Bool `{
- EGLBoolean r = eglInitialize(recv, NULL, NULL);
+ EGLBoolean r = eglInitialize(self, NULL, NULL);
if (r == EGL_FALSE) {
fprintf(stderr, "Unable to eglInitialize");
return 0;
fun major_version: Int `{
EGLint val;
- eglInitialize(recv, &val, NULL);
+ eglInitialize(self, &val, NULL);
return val;
`}
fun minor_version: Int `{
EGLint val;
- eglInitialize(recv, NULL, &val);
+ eglInitialize(self, NULL, &val);
return val;
`}
}
// get number of configs
- EGLBoolean r = eglChooseConfig(recv, c_attribs, NULL, 0, &n_configs);
+ EGLBoolean r = eglChooseConfig(self, c_attribs, NULL, 0, &n_configs);
if (r == EGL_FALSE) {
- EGLDisplay_report_egl_error(recv, "failed to get number of available configs.");
+ EGLDisplay_report_egl_error(self, "failed to get number of available configs.");
return null_Array_of_EGLConfig();
} else if (n_configs == 0) {
- EGLDisplay_report_egl_error(recv, "no config available.");
+ EGLDisplay_report_egl_error(self, "no config available.");
return null_Array_of_EGLConfig();
}
configs = (EGLConfig*)malloc(sizeof(EGLConfig)*n_configs);
- r = eglChooseConfig(recv, c_attribs, configs, n_configs, &n_configs);
+ r = eglChooseConfig(self, c_attribs, configs, n_configs, &n_configs);
if (r == EGL_FALSE) {
- EGLDisplay_report_egl_error(recv, "failed to load config.");
+ EGLDisplay_report_egl_error(self, "failed to load config.");
return null_Array_of_EGLConfig();
} else {
Array_of_EGLConfig array = new_Array_of_EGLConfig();
# Can be used directly, but it is preferable to use a `EGLConfigAttribs`
fun config_attrib(config: EGLConfig, attribute: Int): Int `{
EGLint val;
- EGLBoolean r = eglGetConfigAttrib(recv, config, attribute, &val);
+ EGLBoolean r = eglGetConfigAttrib(self, config, attribute, &val);
if (r == EGL_FALSE)
return -1;
else
`}
fun terminate: Bool `{
- return eglTerminate(recv) == EGL_TRUE;
+ return eglTerminate(self) == EGL_TRUE;
`}
fun create_window_surface(config: EGLConfig, native_window: Pointer, attribs: Array[Int]): EGLSurface `{
- EGLSurface surface = eglCreateWindowSurface(recv, config, (EGLNativeWindowType)native_window, NULL);
+ EGLSurface surface = eglCreateWindowSurface(self, config, (EGLNativeWindowType)native_window, NULL);
return surface;
`}
# TODO add share_context
fun create_context(config: EGLConfig): EGLContext `{
EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE}; // TODO move out!
- EGLContext context = eglCreateContext(recv, config, EGL_NO_CONTEXT, context_attribs);
+ EGLContext context = eglCreateContext(self, config, EGL_NO_CONTEXT, context_attribs);
return context;
`}
fun make_current(draw, read: EGLSurface, context: EGLContext): Bool `{
- if (eglMakeCurrent(recv, draw, read, context) == EGL_FALSE) {
+ if (eglMakeCurrent(self, draw, read, context) == EGL_FALSE) {
fprintf(stderr, "Unable to eglMakeCurrent");
return 0;
}
# Can be used directly, but it is preferable to use a `EGLSurfaceAttribs`
fun query_surface(surface: EGLSurface, attribute: Int): Int `{
int val;
- EGLBoolean r = eglQuerySurface(recv, surface, attribute, &val);
+ EGLBoolean r = eglQuerySurface(self, surface, attribute, &val);
if (r == EGL_FALSE)
return -1;
else
`}
fun destroy_context(context: EGLContext): Bool `{
- return eglDestroyContext(recv, context);
+ return eglDestroyContext(self, context);
`}
fun destroy_surface(surface: EGLSurface): Bool `{
- return eglDestroySurface(recv, surface);
+ return eglDestroySurface(self, surface);
`}
fun error: EGLError `{ return eglGetError(); `}
end
private fun query_string(name: Int): String import NativeString.to_s `{
- return NativeString_to_s((char *)eglQueryString(recv, name));
+ return NativeString_to_s((char *)eglQueryString(self, name));
`}
fun vendor: String do return query_string(0x3053)
fun client_apis: Array[String] do return query_string(0x308D).split_with(" ")
- fun swap_buffers(surface: EGLSurface) `{ eglSwapBuffers(recv, surface); `}
+ fun swap_buffers(surface: EGLSurface) `{ eglSwapBuffers(self, surface); `}
end
extern class EGLConfig `{ EGLConfig `}
new current_read `{ return eglGetCurrentSurface(EGL_READ); `}
new none `{ return EGL_NO_SURFACE; `}
- fun is_ok: Bool `{ return recv != EGL_NO_SURFACE; `}
+ fun is_ok: Bool `{ return self != EGL_NO_SURFACE; `}
fun attribs(display: EGLDisplay): EGLSurfaceAttribs do
return new EGLSurfaceAttribs(display, self)
new current `{ return eglGetCurrentContext(); `}
new none `{ return EGL_NO_CONTEXT; `}
- fun is_ok: Bool `{ return recv != EGL_NO_CONTEXT; `}
+ fun is_ok: Bool `{ return self != EGL_NO_CONTEXT; `}
end
# Attributes of a config for a given EGL display
extern class EGLConfigCaveat `{ EGLint `}
new from_i(val: Int) `{ return (EGLint)val; `}
- fun to_i: Int `{ return recv; `}
+ fun to_i: Int `{ return self; `}
new none `{ return EGL_NONE; `}
- fun is_none: Bool `{ return recv == EGL_NONE; `}
+ fun is_none: Bool `{ return self == EGL_NONE; `}
new dont_care `{ return EGL_DONT_CARE; `}
- fun is_dont_care: Bool `{ return recv == EGL_DONT_CARE; `}
+ fun is_dont_care: Bool `{ return self == EGL_DONT_CARE; `}
new slow `{ return EGL_SLOW_CONFIG; `}
- fun is_slow: Bool `{ return recv == EGL_SLOW_CONFIG; `}
+ fun is_slow: Bool `{ return self == EGL_SLOW_CONFIG; `}
# Obselete since EGL 1.3, use EGL_CONFORMANT instead
new non_conformant `{ return EGL_NON_CONFORMANT_CONFIG; `}
- fun is_non_conformant: Bool `{ return recv == EGL_NON_CONFORMANT_CONFIG; `}
+ fun is_non_conformant: Bool `{ return self == EGL_NON_CONFORMANT_CONFIG; `}
redef fun to_s
do
extern class EGLConformant `{ EGLint `}
new `{ return (EGLint)0; `}
new from_i(val: Int) `{ return (EGLint)val; `}
- fun to_i: Int `{ return recv; `}
+ fun to_i: Int `{ return self; `}
- fun opengl: Bool `{ return recv & EGL_OPENGL_BIT; `}
- fun with_opengl: EGLConformant `{ return recv | EGL_OPENGL_BIT; `}
+ fun opengl: Bool `{ return self & EGL_OPENGL_BIT; `}
+ fun with_opengl: EGLConformant `{ return self | EGL_OPENGL_BIT; `}
- fun opengl_es: Bool `{ return recv & EGL_OPENGL_ES_BIT; `}
- fun with_opengl_es: EGLConformant `{ return recv | EGL_OPENGL_ES_BIT; `}
+ fun opengl_es: Bool `{ return self & EGL_OPENGL_ES_BIT; `}
+ fun with_opengl_es: EGLConformant `{ return self | EGL_OPENGL_ES_BIT; `}
- fun opengl_es2: Bool `{ return recv & EGL_OPENGL_ES2_BIT; `}
- fun with_opengl_es2: EGLConformant `{ return recv | EGL_OPENGL_ES2_BIT; `}
+ fun opengl_es2: Bool `{ return self & EGL_OPENGL_ES2_BIT; `}
+ fun with_opengl_es2: EGLConformant `{ return self | EGL_OPENGL_ES2_BIT; `}
- fun openvg: Bool `{ return recv & EGL_OPENVG_BIT; `}
- fun with_openvg: EGLConformant `{ return recv | EGL_OPENVG_BIT; `}
+ fun openvg: Bool `{ return self & EGL_OPENVG_BIT; `}
+ fun with_openvg: EGLConformant `{ return self | EGL_OPENVG_BIT; `}
fun to_a: Array[String]
do
end
extern class EGLError `{ EGLint `}
- fun is_success: Bool `{ return recv == EGL_SUCCESS; `}
-
- fun is_not_initialized: Bool `{ return recv == EGL_NOT_INITIALIZED; `}
- fun is_bad_access: Bool `{ return recv == EGL_BAD_ACCESS; `}
- fun is_bad_alloc: Bool `{ return recv == EGL_BAD_ALLOC; `}
- fun is_bad_attribute: Bool `{ return recv == EGL_BAD_ATTRIBUTE; `}
- fun is_bad_config: Bool `{ return recv == EGL_BAD_CONFIG; `}
- fun is_bad_context: Bool `{ return recv == EGL_BAD_CONTEXT; `}
- fun is_bad_current_surface: Bool `{ return recv == EGL_BAD_CURRENT_SURFACE; `}
- fun is_bad_display: Bool `{ return recv == EGL_BAD_DISPLAY; `}
- fun is_bad_match: Bool `{ return recv == EGL_BAD_MATCH; `}
- fun is_bad_native_pixmap: Bool `{ return recv == EGL_BAD_NATIVE_PIXMAP; `}
- fun is_bad_native_window: Bool `{ return recv == EGL_BAD_NATIVE_WINDOW; `}
- fun is_bad_parameter: Bool `{ return recv == EGL_BAD_PARAMETER; `}
- fun is_bad_surface: Bool `{ return recv == EGL_BAD_SURFACE; `}
- fun is_context_lost: Bool `{ return recv == EGL_CONTEXT_LOST; `}
+ fun is_success: Bool `{ return self == EGL_SUCCESS; `}
+
+ fun is_not_initialized: Bool `{ return self == EGL_NOT_INITIALIZED; `}
+ fun is_bad_access: Bool `{ return self == EGL_BAD_ACCESS; `}
+ fun is_bad_alloc: Bool `{ return self == EGL_BAD_ALLOC; `}
+ fun is_bad_attribute: Bool `{ return self == EGL_BAD_ATTRIBUTE; `}
+ fun is_bad_config: Bool `{ return self == EGL_BAD_CONFIG; `}
+ fun is_bad_context: Bool `{ return self == EGL_BAD_CONTEXT; `}
+ fun is_bad_current_surface: Bool `{ return self == EGL_BAD_CURRENT_SURFACE; `}
+ fun is_bad_display: Bool `{ return self == EGL_BAD_DISPLAY; `}
+ fun is_bad_match: Bool `{ return self == EGL_BAD_MATCH; `}
+ fun is_bad_native_pixmap: Bool `{ return self == EGL_BAD_NATIVE_PIXMAP; `}
+ fun is_bad_native_window: Bool `{ return self == EGL_BAD_NATIVE_WINDOW; `}
+ fun is_bad_parameter: Bool `{ return self == EGL_BAD_PARAMETER; `}
+ fun is_bad_surface: Bool `{ return self == EGL_BAD_SURFACE; `}
+ fun is_context_lost: Bool `{ return self == EGL_CONTEXT_LOST; `}
redef fun to_s
do
(self.back <= other.front and other.back <= self.front))
end
- redef fun padded(dist: N): Box3d[N] do return new Box3d[N].lrtbfb(left - dist, right + dist, top + dist, bottom - dist, front + dist, back - dist)
+ redef fun padded(dist): Box3d[N] do return new Box3d[N].lrtbfb(left - dist, right + dist, top + dist, bottom - dist, front + dist, back - dist)
end
# A 3d bounded object and an implementation of Boxed
private var data: Array[E] = new Array[E]
- redef fun add(item: E) do data.add(item)
- redef fun items_overlapping(item: Boxed[Numeric]): SimpleCollection[E]
+ redef fun add(item) do data.add(item)
+ redef fun items_overlapping(item): SimpleCollection[E]
do
var arr = new Array[E]
for i in data do
class Line[N: Numeric]
super ILine[N]
- redef var point_left: P
- redef var point_right: P
+ redef var point_left
+ redef var point_right
init
do
self.parent_node = parent
end
- redef fun items_overlapping(region :Boxed[Numeric]): SimpleCollection[E] do
+ redef fun items_overlapping(region): SimpleCollection[E] do
var res = new Array[E]
items_overlapping_in(region,res)
return res
end
# add the item to the tree, create children if the limit is reached
- redef fun add(item: E) do if self.is_leaf then self.data.add(item) else add_to_children(item)
+ redef fun add(item) do if self.is_leaf then self.data.add(item) else add_to_children(item)
private fun add_to_children(item: Boxed[Numeric])
do
end
end
- redef fun is_empty: Bool do return data.is_empty and (self.is_leaf or (child0.is_empty and child1.is_empty and child2.is_empty and child3.is_empty))
+ redef fun is_empty do return data.is_empty and (self.is_leaf or (child0.is_empty and child1.is_empty and child2.is_empty and child3.is_empty))
# Return whether or not the Node is a leaf of the tree
fun is_leaf: Bool do return child0 == null
#
# For more info, SEE setlocale manual
fun set_locale `{
- setlocale(LC_ALL, recv);
+ setlocale(LC_ALL, self);
`}
end
# Gettext `gettext`, SEE gettext manual for further info
fun gettext: String
import String.to_cstring, NativeString.to_s `{
- return NativeString_to_s(gettext(String_to_cstring(recv)));
+ return NativeString_to_s(gettext(String_to_cstring(self)));
`}
# Gettext `dgettext`, SEE gettext manual for further info
fun dgettext(domain: String): String
import String.to_cstring, NativeString.to_s `{
- return NativeString_to_s(dgettext(String_to_cstring(domain), String_to_cstring(recv)));
+ return NativeString_to_s(dgettext(String_to_cstring(domain), String_to_cstring(self)));
`}
end
var config = configs.first
# TODO android part
-# Opengles1Display_midway_init(recv, format);
+# Opengles1Display_midway_init(self, format);
var surface = egl_display.create_window_surface(config, x11_window_handle, [0])
assert surface.is_ok else print egl_display.error
new `{ return glCreateProgram(); `}
# Is this a valid program?
- fun is_ok: Bool `{ return glIsProgram(recv); `}
+ fun is_ok: Bool `{ return glIsProgram(self); `}
# Attach a `shader` to this program
- fun attach_shader(shader: GLShader) `{ glAttachShader(recv, shader); `}
+ fun attach_shader(shader: GLShader) `{ glAttachShader(self, shader); `}
# Set the location for the attribute by `name`
fun bind_attrib_location(index: Int, name: String) import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- glBindAttribLocation(recv, index, c_name);
+ glBindAttribLocation(self, index, c_name);
`}
# Get the location of the attribute by `name`
# Returns `-1` if there is no active attribute named `name`.
fun attrib_location(name: String): Int import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- return glGetAttribLocation(recv, c_name);
+ return glGetAttribLocation(self, c_name);
`}
# Get the location of the uniform by `name`
# Returns `-1` if there is no active uniform named `name`.
fun uniform_location(name: String): Int import String.to_cstring `{
GLchar *c_name = String_to_cstring(name);
- return glGetUniformLocation(recv, c_name);
+ return glGetUniformLocation(self, c_name);
`}
# Query information on this program
fun query(pname: Int): Int `{
int val;
- glGetProgramiv(recv, pname, &val);
+ glGetProgramiv(self, pname, &val);
return val;
`}
# Try to link this program
#
# Check result using `in_linked` and `info_log`.
- fun link `{ glLinkProgram(recv); `}
+ fun link `{ glLinkProgram(self); `}
# Is this program linked?
fun is_linked: Bool do return query(0x8B82) != 0
# Use this program for the following operations
- fun use `{ glUseProgram(recv); `}
+ fun use `{ glUseProgram(self); `}
# Delete this program
- fun delete `{ glDeleteProgram(recv); `}
+ fun delete `{ glDeleteProgram(self); `}
# Has this program been deleted?
fun is_deleted: Bool do return query(0x8B80) != 0
# Validate whether this program can be executed in the current OpenGL state
#
# Check results using `is_validated` and `info_log`.
- fun validate `{ glValidateProgram(recv); `}
+ fun validate `{ glValidateProgram(self); `}
# Boolean result of `validate`, must be called after `validate`
fun is_validated: Bool do return query(0x8B83) != 0
# Useful with `link` and `validate`
fun info_log: String import NativeString.to_s `{
int size;
- glGetProgramiv(recv, GL_INFO_LOG_LENGTH, &size);
+ glGetProgramiv(self, GL_INFO_LOG_LENGTH, &size);
GLchar *msg = malloc(size);
- glGetProgramInfoLog(recv, size, NULL, msg);
+ glGetProgramInfoLog(self, size, NULL, msg);
return NativeString_to_s(msg);
`}
char *name = malloc(max_size);
int size;
GLenum type;
- glGetActiveAttrib(recv, index, max_size, NULL, &size, &type, name);
+ glGetActiveAttrib(self, index, max_size, NULL, &size, &type, name);
return name;
`}
fun active_attrib_size(index: Int): Int `{
int size;
GLenum type;
- glGetActiveAttrib(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveAttrib(self, index, 0, NULL, &size, &type, NULL);
return size;
`}
fun active_attrib_type(index: Int): GLFloatDataType `{
int size;
GLenum type;
- glGetActiveAttrib(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveAttrib(self, index, 0, NULL, &size, &type, NULL);
return type;
`}
char *name = malloc(max_size);
int size;
GLenum type;
- glGetActiveUniform(recv, index, max_size, NULL, &size, &type, name);
+ glGetActiveUniform(self, index, max_size, NULL, &size, &type, name);
return name;
`}
fun active_uniform_size(index: Int): Int `{
int size;
GLenum type;
- glGetActiveUniform(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveUniform(self, index, 0, NULL, &size, &type, NULL);
return size;
`}
fun active_uniform_type(index: Int): GLDataType `{
int size;
GLenum type = 0;
- glGetActiveUniform(recv, index, 0, NULL, &size, &type, NULL);
+ glGetActiveUniform(self, index, 0, NULL, &size, &type, NULL);
return type;
`}
end
extern class GLShader `{GLuint`}
# Set the source of the shader
fun source=(code: NativeString) `{
- glShaderSource(recv, 1, (GLchar const **)&code, NULL);
+ glShaderSource(self, 1, (GLchar const **)&code, NULL);
`}
# Source of the shader, if available
private fun source_native(size: Int): NativeString `{
GLchar *code = malloc(size);
- glGetShaderSource(recv, size, NULL, code);
+ glGetShaderSource(self, size, NULL, code);
return code;
`}
# Query information on this shader
protected fun query(pname: Int): Int `{
int val;
- glGetShaderiv(recv, pname, &val);
+ glGetShaderiv(self, pname, &val);
return val;
`}
# Try to compile `source` into a binary GPU program
#
# Check the result using `is_compiled` and `info_log`
- fun compile `{ glCompileShader(recv); `}
+ fun compile `{ glCompileShader(self); `}
# Has this shader been compiled?
fun is_compiled: Bool do return query(0x8B81) != 0
# Delete this shader
- fun delete `{ glDeleteShader(recv); `}
+ fun delete `{ glDeleteShader(self); `}
# Has this shader been deleted?
fun is_deleted: Bool do return query(0x8B80) != 0
# Is this a valid shader?
- fun is_ok: Bool `{ return glIsShader(recv); `}
+ fun is_ok: Bool `{ return glIsShader(self); `}
# Retrieve the information log of this shader
#
# Useful with `link` and `validate`
fun info_log: String import NativeString.to_s `{
int size;
- glGetShaderiv(recv, GL_INFO_LOG_LENGTH, &size);
+ glGetShaderiv(self, GL_INFO_LOG_LENGTH, &size);
GLchar *msg = malloc(size);
- glGetShaderInfoLog(recv, size, NULL, msg);
+ glGetShaderInfoLog(self, size, NULL, msg);
return NativeString_to_s(msg);
`}
end
# General type for OpenGL enumerations
extern class GLEnum `{ GLenum `}
- redef fun hash `{ return recv; `}
+ redef fun hash `{ return self; `}
redef fun ==(o) do return o != null and is_same_type(o) and o.hash == self.hash
end
fun is_ok: Bool do return is_no_error
# Is this not an error?
- fun is_no_error: Bool `{ return recv == GL_NO_ERROR; `}
+ fun is_no_error: Bool `{ return self == GL_NO_ERROR; `}
- fun is_invalid_enum: Bool `{ return recv == GL_INVALID_ENUM; `}
- fun is_invalid_value: Bool `{ return recv == GL_INVALID_VALUE; `}
- fun is_invalid_operation: Bool `{ return recv == GL_INVALID_OPERATION; `}
- fun is_invalid_framebuffer_operation: Bool `{ return recv == GL_INVALID_FRAMEBUFFER_OPERATION; `}
- fun is_out_of_memory: Bool `{ return recv == GL_OUT_OF_MEMORY; `}
+ fun is_invalid_enum: Bool `{ return self == GL_INVALID_ENUM; `}
+ fun is_invalid_value: Bool `{ return self == GL_INVALID_VALUE; `}
+ fun is_invalid_operation: Bool `{ return self == GL_INVALID_OPERATION; `}
+ fun is_invalid_framebuffer_operation: Bool `{ return self == GL_INVALID_FRAMEBUFFER_OPERATION; `}
+ fun is_out_of_memory: Bool `{ return self == GL_OUT_OF_MEMORY; `}
redef fun to_s
do
extern class GLFloatDataType
super GLEnum
- fun is_float: Bool `{ return recv == GL_FLOAT; `}
- fun is_float_vec2: Bool `{ return recv == GL_FLOAT_VEC2; `}
- fun is_float_vec3: Bool `{ return recv == GL_FLOAT_VEC3; `}
- fun is_float_vec4: Bool `{ return recv == GL_FLOAT_VEC4; `}
- fun is_float_mat2: Bool `{ return recv == GL_FLOAT_MAT2; `}
- fun is_float_mat3: Bool `{ return recv == GL_FLOAT_MAT3; `}
- fun is_float_mat4: Bool `{ return recv == GL_FLOAT_MAT4; `}
+ fun is_float: Bool `{ return self == GL_FLOAT; `}
+ fun is_float_vec2: Bool `{ return self == GL_FLOAT_VEC2; `}
+ fun is_float_vec3: Bool `{ return self == GL_FLOAT_VEC3; `}
+ fun is_float_vec4: Bool `{ return self == GL_FLOAT_VEC4; `}
+ fun is_float_mat2: Bool `{ return self == GL_FLOAT_MAT2; `}
+ fun is_float_mat3: Bool `{ return self == GL_FLOAT_MAT3; `}
+ fun is_float_mat4: Bool `{ return self == GL_FLOAT_MAT4; `}
# Instances of `GLFloatDataType` can be equal to instances of `GLDataType`
redef fun ==(o)
extern class GLDataType
super GLFloatDataType
- fun is_int: Bool `{ return recv == GL_INT; `}
- fun is_int_vec2: Bool `{ return recv == GL_INT_VEC2; `}
- fun is_int_vec3: Bool `{ return recv == GL_INT_VEC3; `}
- fun is_int_vec4: Bool `{ return recv == GL_INT_VEC4; `}
- fun is_bool: Bool `{ return recv == GL_BOOL; `}
- fun is_bool_vec2: Bool `{ return recv == GL_BOOL_VEC2; `}
- fun is_bool_vec3: Bool `{ return recv == GL_BOOL_VEC3; `}
- fun is_bool_vec4: Bool `{ return recv == GL_BOOL_VEC4; `}
- fun is_sampler_2d: Bool `{ return recv == GL_SAMPLER_2D; `}
- fun is_sampler_cube: Bool `{ return recv == GL_SAMPLER_CUBE; `}
+ fun is_int: Bool `{ return self == GL_INT; `}
+ fun is_int_vec2: Bool `{ return self == GL_INT_VEC2; `}
+ fun is_int_vec3: Bool `{ return self == GL_INT_VEC3; `}
+ fun is_int_vec4: Bool `{ return self == GL_INT_VEC4; `}
+ fun is_bool: Bool `{ return self == GL_BOOL; `}
+ fun is_bool_vec2: Bool `{ return self == GL_BOOL_VEC2; `}
+ fun is_bool_vec3: Bool `{ return self == GL_BOOL_VEC3; `}
+ fun is_bool_vec4: Bool `{ return self == GL_BOOL_VEC4; `}
+ fun is_sampler_2d: Bool `{ return self == GL_SAMPLER_2D; `}
+ fun is_sampler_cube: Bool `{ return self == GL_SAMPLER_CUBE; `}
end
# Kind of primitives to render with `GLES::draw_arrays`
new `{ return 0; `}
# Add the color buffer to the returned buffer set
- fun color: GLBuffer `{ return recv | GL_COLOR_BUFFER_BIT; `}
+ fun color: GLBuffer `{ return self | GL_COLOR_BUFFER_BIT; `}
# Add the depth buffer to the returned buffer set
- fun depth: GLBuffer `{ return recv | GL_DEPTH_BUFFER_BIT; `}
+ fun depth: GLBuffer `{ return self | GL_DEPTH_BUFFER_BIT; `}
# Add the stencil buffer to the returned buffer set
- fun stencil: GLBuffer `{ return recv | GL_STENCIL_BUFFER_BIT; `}
+ fun stencil: GLBuffer `{ return self | GL_STENCIL_BUFFER_BIT; `}
end
`}
fun current_page: Int `{
- return gtk_assistant_get_current_page (recv);
+ return gtk_assistant_get_current_page (self);
`}
fun current_page=(page_num: Int) `{
- gtk_assistant_set_current_page(recv, page_num);
+ gtk_assistant_set_current_page(self, page_num);
`}
fun number_pages: Int `{
- return gtk_assistant_get_n_pages(recv);
+ return gtk_assistant_get_n_pages(self);
`}
fun get_page(page_num: Int): GtkWidget `{
- return gtk_assistant_get_nth_page(recv, page_num);
+ return gtk_assistant_get_nth_page(self, page_num);
`}
fun prepend(page: GtkWidget): Int `{
- return gtk_assistant_prepend_page(recv, page);
+ return gtk_assistant_prepend_page(self, page);
`}
fun append(page: GtkWidget): Int `{
- return gtk_assistant_append_page(recv, page);
+ return gtk_assistant_append_page(self, page);
`}
fun insert(page: GtkWidget, position: Int): Int `{
- return gtk_assistant_insert_page(recv, page, position);
+ return gtk_assistant_insert_page(self, page, position);
`}
fun remove(page_num: Int) `{
- gtk_assistant_remove_page(recv, page_num);
+ gtk_assistant_remove_page(self, page_num);
`}
fun get_page_type(page: GtkWidget): GtkAssistantPageType `{
- return gtk_assistant_get_page_type(recv, page);
+ return gtk_assistant_get_page_type(self, page);
`}
fun set_page_type(page: GtkWidget, t: GtkAssistantPageType) `{
- gtk_assistant_set_page_type(recv, page, t);
+ gtk_assistant_set_page_type(self, page, t);
`}
fun get_page_title(page: GtkWidget): String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_assistant_get_page_title(recv, page));
+ return NativeString_to_s((char *)gtk_assistant_get_page_title(self, page));
`}
fun set_page_title(page: GtkWidget, title: String) import String.to_cstring `{
- gtk_assistant_set_page_title(recv, page, String_to_cstring(title));
+ gtk_assistant_set_page_title(self, page, String_to_cstring(title));
`}
fun set_page_complete(page: GtkWidget, is_complete: Bool) `{
- gtk_assistant_set_page_complete(recv, page, is_complete);
+ gtk_assistant_set_page_complete(self, page, is_complete);
`}
fun get_page_complete(page: GtkWidget): Bool `{
- return gtk_assistant_get_page_complete(recv, page);
+ return gtk_assistant_get_page_complete(self, page);
`}
fun remove_action_widget(child: GtkWidget) `{
- gtk_assistant_remove_action_widget(recv, child);
+ gtk_assistant_remove_action_widget(self, child);
`}
fun add_action_widget(child: GtkWidget) `{
- gtk_assistant_add_action_widget(recv, child);
+ gtk_assistant_add_action_widget(self, child);
`}
fun update_buttons_state `{
- gtk_assistant_update_buttons_state(recv);
+ gtk_assistant_update_buttons_state(self);
`}
fun commit `{
- gtk_assistant_commit(recv);
+ gtk_assistant_commit(self);
`}
fun next_page `{
- gtk_assistant_next_page(recv);
+ gtk_assistant_next_page(self);
`}
fun previous_page `{
- gtk_assistant_previous_page(recv);
+ gtk_assistant_previous_page(self);
`}
end
# Base class for all widgets
# See: https://developer.gnome.org/gtk3/stable/GtkWidget.html
extern class GtkWidget `{GtkWidget *`}
- fun show_all `{ gtk_widget_show_all(recv); `}
+ fun show_all `{ gtk_widget_show_all(self); `}
fun signal_connect(signal_name: String, to_call: GtkCallable, user_data: nullable Object) import String.to_cstring, GtkCallable.signal, Object.as not nullable `{
NitGtkSignal *data = malloc(sizeof(NitGtkSignal));
data->user_data = user_data;
/*Use G_CALLBACK() to cast the callback function to a GCallback*/
- g_signal_connect(recv,
+ g_signal_connect(self,
String_to_cstring(signal_name),
G_CALLBACK(nit_gtk_callback_func),
data);
redef fun ==(o) do return o isa GtkWidget and equal_to_gtk_widget(o)
private fun equal_to_gtk_widget(o: GtkWidget): Bool `{
- return recv == o;
+ return self == o;
`}
fun request_size(width, height: Int) `{
- gtk_widget_set_size_request(recv, width, height);
+ gtk_widget_set_size_request(self, width, height);
`}
fun bg_color=(state: GtkStateType, color: GdkRGBA) `{
- gtk_widget_override_background_color(recv, state, color);
+ gtk_widget_override_background_color(self, state, color);
`}
# with gtk it's possible to set fg_color to all widget: is it correct? is fg color inherited?
# GdkColor color;
fun fg_color=(state: GtkStateType, color: GdkRGBA) `{
- gtk_widget_override_color(recv, state, color);
+ gtk_widget_override_color(self, state, color);
`}
# Sets the sensitivity of a widget. sensitive -> the user can interact with it.
# Insensitive -> widget "grayed out" and the user can"t interact with them
fun sensitive=(sensitive: Bool) `{
- gtk_widget_set_sensitive(recv, sensitive);
+ gtk_widget_set_sensitive(self, sensitive);
`}
# return the sensitivity of the widget
fun sensitive: Bool `{
- return gtk_widget_get_sensitive(recv);
+ return gtk_widget_get_sensitive(self);
`}
# Set the visibility of the widget
fun visible=(visible: Bool) `{
- gtk_widget_set_visible(recv, visible);
+ gtk_widget_set_visible(self, visible);
`}
# Get the visibility of the widget only
fun visible_self: Bool `{
- return gtk_widget_get_visible(recv);
+ return gtk_widget_get_visible(self);
`}
# Destroy the widget
- fun destroy `{ gtk_widget_destroy(recv); `}
+ fun destroy `{ gtk_widget_destroy(self); `}
# Show the widget on screen
#
# See: `show_all` to recursively show this widget and contained widgets.
- fun show `{ gtk_widget_show(recv); `}
+ fun show `{ gtk_widget_show(self); `}
# Hide the widget (reverse the effects of `show`)
- fun hide `{ gtk_widget_hide(recv); `}
+ fun hide `{ gtk_widget_hide(self); `}
end
# Base class for widgets which contain other widgets
# Add a widget to the container
fun add(widget: GtkWidget) `{
- gtk_container_add(recv, widget);
+ gtk_container_add(self, widget);
`}
# Remove the widget from the container
fun remove_widget(widget: GtkWidget) `{
- gtk_container_remove(recv, widget);
+ gtk_container_remove(self, widget);
`}
# Get the resize mode of the container
fun resize_mode: GtkResizeMode `{
- return gtk_container_get_resize_mode(recv);
+ return gtk_container_get_resize_mode(self);
`}
# Set the resize mode of the container
fun resize_mode=(resize_mode: GtkResizeMode) `{
- gtk_container_set_resize_mode(recv, resize_mode);
+ gtk_container_set_resize_mode(self, resize_mode);
`}
end
super GtkContainer
fun child: GtkWidget `{
- return gtk_bin_get_child(recv);
+ return gtk_bin_get_child(self);
`}
end
# Connect the "destroy" signal to `quit_gtk`
fun connect_destroy_signal_to_quit `{
- g_signal_connect(recv, "destroy", G_CALLBACK(gtk_main_quit), NULL);
+ g_signal_connect(self, "destroy", G_CALLBACK(gtk_main_quit), NULL);
`}
fun title=(title: String) import String.to_cstring `{
- gtk_window_set_title(recv, String_to_cstring(title));
+ gtk_window_set_title(self, String_to_cstring(title));
`}
# The "destroy" signal is emitted when a widget is destroyed, either by explicitly calling gtk_widget_destroy() or when the widget is unparented. Top-level GtkWindows are also destroyed when the Close window control button is clicked.
end
fun resizable: Bool `{
- return gtk_window_get_resizable(recv);
+ return gtk_window_get_resizable(self);
`}
fun resizable=(is_resizable: Bool) `{
- return gtk_window_set_resizable(recv, is_resizable);
+ return gtk_window_set_resizable(self, is_resizable);
`}
# Activates the current focused widget within the window.
# returns TRUE if a widget got activated.
fun activate_focus: Bool `{
- return gtk_window_activate_focus(recv);
+ return gtk_window_activate_focus(self);
`}
# Sets a window modal or non-modal. Modal windows prevent interaction with other windows in the same application.
fun modal=(is_modal: Bool) `{
- gtk_window_set_modal(recv, is_modal);
+ gtk_window_set_modal(self, is_modal);
`}
# Windows can't actually be 0x0 in size, they must be at least 1x1
# params width in pixels, or -1 to unset the default width
# params height in pixels, or -1 to unset the default height
fun default_size(width: Int, height: Int) `{
- gtk_window_set_default_size(recv, width, height);
+ gtk_window_set_default_size(self, width, height);
`}
# Activates the default widget for the window
# unless the current focused widget has been configured to receive the default action (see gtk_widget_set_receives_default()), in which case the focused widget is activated.
fun activate_default: Bool `{
- return gtk_window_activate_default(recv);
+ return gtk_window_activate_default(self);
`}
fun gravity: GdkGravity `{
- return gtk_window_get_gravity(recv);
+ return gtk_window_get_gravity(self);
`}
fun gravity=(window_grav: GdkGravity) `{
- gtk_window_set_gravity(recv, window_grav);
+ gtk_window_set_gravity(self, window_grav);
`}
# fun position: GtkWindowPosition `{
-# return gtk_window_get_position(recv);
+# return gtk_window_get_position(self);
# `}
#
# fun position=(window_pos: GtkWindowPosition) `{
-# gtk_window_set_position(recv, window_pos);
+# gtk_window_set_position(self, window_pos);
# `}
fun active: Bool `{
- return gtk_window_is_active(recv);
+ return gtk_window_is_active(self);
`}
# Returns whether the input focus is within this GtkWindow. For real toplevel windows, this is identical to gtk_window_is_active(), but for embedded windows, like GtkPlug, the results will differ.
fun has_toplevel_focus: Bool `{
- return gtk_window_has_toplevel_focus(recv);
+ return gtk_window_has_toplevel_focus(self);
`}
fun get_focus: GtkWidget `{
- return gtk_window_get_focus(recv);
+ return gtk_window_get_focus(self);
`}
fun set_focus(widget: GtkWidget) `{
- return gtk_window_set_focus(recv, widget);
+ return gtk_window_set_focus(self, widget);
`}
fun get_default_widget: GtkWidget `{
- return gtk_window_get_default_widget(recv);
+ return gtk_window_get_default_widget(self);
`}
fun set_default_widget(widget: GtkWidget) `{
- return gtk_window_set_default(recv, widget);
+ return gtk_window_set_default(self, widget);
`}
fun maximize `{
- return gtk_window_maximize(recv);
+ return gtk_window_maximize(self);
`}
fun unmaximize `{
- return gtk_window_unmaximize(recv);
+ return gtk_window_unmaximize(self);
`}
fun fullscreen `{
- return gtk_window_fullscreen(recv);
+ return gtk_window_fullscreen(self);
`}
fun unfullscreen `{
- return gtk_window_unfullscreen(recv);
+ return gtk_window_unfullscreen(self);
`}
fun keep_above=(setting: Bool) `{
- gtk_window_set_keep_above(recv, setting);
+ gtk_window_set_keep_above(self, setting);
`}
fun keep_below=(setting: Bool) `{
- gtk_window_set_keep_below(recv, setting);
+ gtk_window_set_keep_below(self, setting);
`}
end
`}
fun frame_label: String `{
- return NativeString_to_s((char *)gtk_frame_get_label(recv));
+ return NativeString_to_s((char *)gtk_frame_get_label(self));
`}
fun frame_label=(lbl: String) import String.to_cstring `{
- gtk_frame_set_label(recv, String_to_cstring(lbl));
+ gtk_frame_set_label(self, String_to_cstring(lbl));
`}
fun label_widget: GtkWidget `{
- return gtk_frame_get_label_widget(recv);
+ return gtk_frame_get_label_widget(self);
`}
fun label_widget=(widget: GtkWidget) `{
- gtk_frame_set_label_widget(recv, widget);
+ gtk_frame_set_label_widget(self, widget);
`}
fun shadow_type: GtkShadowType `{
- return gtk_frame_get_shadow_type(recv);
+ return gtk_frame_get_shadow_type(self);
`}
fun shadow_type=(stype: GtkShadowType) `{
- gtk_frame_set_shadow_type(recv, stype);
+ gtk_frame_set_shadow_type(self, stype);
`}
fun label_align=(xalign: Float, yalign: Float) `{
- gtk_frame_set_label_align(recv, xalign, yalign);
+ gtk_frame_set_label_align(self, xalign, yalign);
`}
end
# Set a widget child inside the grid at a given position
fun attach(child: GtkWidget, left, top, width, height: Int) `{
- gtk_grid_attach(recv, child, left, top, width, height);
+ gtk_grid_attach(self, child, left, top, width, height);
`}
# Get the child of the Grid at the given position
fun get_child_at(left: Int, top: Int): GtkWidget `{
- return gtk_grid_get_child_at(recv, left, top);
+ return gtk_grid_get_child_at(self, left, top);
`}
# Insert a row at the specified position
fun insert_row(position:Int) `{
- gtk_grid_insert_row(recv, position);
+ gtk_grid_insert_row(self, position);
`}
# Insert a column at the specified position
fun insert_column(position: Int) `{
- gtk_grid_insert_column(recv, position);
+ gtk_grid_insert_column(self, position);
`}
end
# Get the orientation of this widget
fun orientation: GtkOrientation `{
- return gtk_orientable_get_orientation(recv);
+ return gtk_orientable_get_orientation(self);
`}
# Set the orientation of this widget
fun orientation=(orientation: GtkOrientation) `{
- gtk_orientable_set_orientation(recv, orientation);
+ gtk_orientable_set_orientation(self, orientation);
`}
end
`}
# Give the children of `self` equal space in the box?
- fun homogeneous: Bool `{ return gtk_box_get_homogeneous(recv); `}
+ fun homogeneous: Bool `{ return gtk_box_get_homogeneous(self); `}
# Give the children of `self` equal space in the box?
fun homogeneous=(homogeneous: Bool) `{
- gtk_box_set_homogeneous(recv, homogeneous);
+ gtk_box_set_homogeneous(self, homogeneous);
`}
# Add `child` and pack it at the start of the box
fun pack_start(child: GtkWidget, expand, fill: Bool, padding: Int) `{
- gtk_box_pack_start(recv, child, expand, fill, padding);
+ gtk_box_pack_start(self, child, expand, fill, padding);
`}
# Add `child` and pack it at the end of the box
fun pack_end(child: GtkWidget, expand, fill: Bool, padding: Int) `{
- gtk_box_pack_end(recv, child, expand, fill, padding);
+ gtk_box_pack_end(self, child, expand, fill, padding);
`}
# Set the way `child` is packed in `self`
fun set_child_packing(child: GtkWidget, expand, fill: Bool, padding: Int, packing: GtkPackType) `{
- gtk_box_set_child_packing(recv, child, expand, fill, padding, packing);
+ gtk_box_set_child_packing(self, child, expand, fill, padding, packing);
`}
end
fun alignment: GtkAlignment is abstract
fun alignment=(x: Float, y: Float) `{
- gtk_misc_set_alignment(recv, x, y);
+ gtk_misc_set_alignment(self, x, y);
`}
fun padding: GtkAlignment is abstract
fun padding=(x: Float, y: Float) `{
- gtk_misc_set_padding(recv, x, y);
+ gtk_misc_set_padding(self, x, y);
`}
end
`}
fun text: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy((char *)gtk_entry_get_text(recv));
+ return NativeString_to_s_with_copy((char *)gtk_entry_get_text(self));
`}
fun text=(value: String) import String.to_cstring `{
- gtk_entry_set_text(recv, String_to_cstring(value));
+ gtk_entry_set_text(self, String_to_cstring(value));
`}
# Is the text visible or is it the invisible char (such as '*')?
fun visiblility: Bool `{
- return gtk_entry_get_visibility(recv);
+ return gtk_entry_get_visibility(self);
`}
# Set the text visiblility
# If false, will use the invisible char (such as '*')
fun visibility=(is_visible: Bool) `{
- gtk_entry_set_visibility(recv, is_visible);
+ gtk_entry_set_visibility(self, is_visible);
`}
fun max_length: Int `{
- return gtk_entry_get_max_length(recv);
+ return gtk_entry_get_max_length(self);
`}
fun max_length=(max: Int) `{
- gtk_entry_set_max_length(recv, max);
+ gtk_entry_set_max_length(self, max);
`}
end
# Gets the current position of the fill level indicator.
fun fill_level: Float `{
- return gtk_range_get_fill_level(recv);
+ return gtk_range_get_fill_level(self);
`}
fun fill_level=(level: Float) `{
- gtk_range_set_fill_level(recv, level);
+ gtk_range_set_fill_level(self, level);
`}
# Gets whether the range is restricted to the fill level.
fun restricted_to_fill_level: Bool `{
- return gtk_range_get_restrict_to_fill_level(recv);
+ return gtk_range_get_restrict_to_fill_level(self);
`}
fun restricted_to_fill_level=(restricted: Bool) `{
- gtk_range_set_restrict_to_fill_level(recv, restricted);
+ gtk_range_set_restrict_to_fill_level(self, restricted);
`}
# Gets whether the range displays the fill level graphically.
fun show_fill_level: Bool `{
- return gtk_range_get_show_fill_level(recv);
+ return gtk_range_get_show_fill_level(self);
`}
fun show_fill_level=(is_displayed: Bool) `{
- gtk_range_set_show_fill_level(recv, is_displayed);
+ gtk_range_set_show_fill_level(self, is_displayed);
`}
fun adjustment: GtkAdjustment `{
- return gtk_range_get_adjustment(recv);
+ return gtk_range_get_adjustment(self);
`}
fun adjustment=(value: GtkAdjustment) `{
- gtk_range_set_adjustment(recv, value);
+ gtk_range_set_adjustment(self, value);
`}
fun inverted: Bool `{
- return gtk_range_get_inverted(recv);
+ return gtk_range_get_inverted(self);
`}
fun inverted=(setting: Bool) `{
- gtk_range_set_inverted(recv, setting);
+ gtk_range_set_inverted(self, setting);
`}
fun value: Float `{
- return gtk_range_get_value(recv);
+ return gtk_range_get_value(self);
`}
fun value=(val: Float) `{
- gtk_range_set_value(recv, val);
+ gtk_range_set_value(self, val);
`}
fun set_increments(step: Float, page: Float) `{
- gtk_range_set_increments(recv, step, page);
+ gtk_range_set_increments(self, step, page);
`}
fun set_range(min: Float, max: Float) `{
- gtk_range_set_range(recv, min, max);
+ gtk_range_set_range(self, min, max);
`}
fun round_digits: Int `{
- return gtk_range_get_round_digits(recv);
+ return gtk_range_get_round_digits(self);
`}
fun round_digits=(nb: Int) `{
- gtk_range_set_round_digits(recv, nb);
+ gtk_range_set_round_digits(self, nb);
`}
fun size_fixed: Bool `{
- return gtk_range_get_slider_size_fixed(recv);
+ return gtk_range_get_slider_size_fixed(self);
`}
fun size_fixed=(is_fixed: Bool) `{
- return gtk_range_set_slider_size_fixed(recv, is_fixed);
+ return gtk_range_set_slider_size_fixed(self, is_fixed);
`}
fun flippable: Bool `{
- return gtk_range_get_flippable(recv);
+ return gtk_range_get_flippable(self);
`}
fun min_size=(is_flippable: Bool) `{
- return gtk_range_set_flippable(recv, is_flippable);
+ return gtk_range_set_flippable(self, is_flippable);
`}
fun min_slider_size: Int `{
- return gtk_range_get_min_slider_size(recv);
+ return gtk_range_get_min_slider_size(self);
`}
fun min_slider_size=(size: Int) `{
- return gtk_range_set_min_slider_size(recv, size);
+ return gtk_range_set_min_slider_size(self, size);
`}
end
`}
fun digits: Int `{
- return gtk_scale_get_digits(recv);
+ return gtk_scale_get_digits(self);
`}
fun digits=(nb_digits: Int) `{
- gtk_scale_set_digits(recv, nb_digits);
+ gtk_scale_set_digits(self, nb_digits);
`}
fun draw_value: Bool `{
- return gtk_scale_get_draw_value(recv);
+ return gtk_scale_get_draw_value(self);
`}
fun draw_value=(is_displayed: Bool) `{
- gtk_scale_set_draw_value(recv, is_displayed);
+ gtk_scale_set_draw_value(self, is_displayed);
`}
fun value_position: GtkPositionType `{
- return gtk_scale_get_value_pos(recv);
+ return gtk_scale_get_value_pos(self);
`}
fun value_position=(pos: GtkPositionType) `{
- gtk_scale_set_value_pos(recv, pos);
+ gtk_scale_set_value_pos(self, pos);
`}
fun has_origin: Bool `{
- return gtk_scale_get_has_origin(recv);
+ return gtk_scale_get_has_origin(self);
`}
fun has_origin=(orig: Bool) `{
- gtk_scale_set_has_origin(recv, orig);
+ gtk_scale_set_has_origin(self, orig);
`}
fun add_mark(value: Float, position: GtkPositionType, markup: String)
import String.to_cstring `{
- gtk_scale_add_mark(recv, value, position, String_to_cstring(markup));
+ gtk_scale_add_mark(self, value, position, String_to_cstring(markup));
`}
# Removes any marks that have been added with gtk_scale_add_mark().
fun clear_marks `{
- gtk_scale_clear_marks(recv);
+ gtk_scale_clear_marks(self);
`}
end
# Set the text of the label
fun text=(text: String) import String.to_cstring `{
- gtk_label_set_text(recv, String_to_cstring(text));
+ gtk_label_set_text(self, String_to_cstring(text));
`}
# Returns the text of the label
fun text: String import NativeString.to_s `{
- return NativeString_to_s((char*)gtk_label_get_text(recv));
+ return NativeString_to_s((char*)gtk_label_get_text(self));
`}
# Sets the angle of rotation for the label.
# An angle of 90 reads from from bottom to top, an angle of 270, from top to bottom.
fun angle=(degre: Float) `{
- gtk_label_set_angle(recv, degre);
+ gtk_label_set_angle(self, degre);
`}
# Returns the angle of rotation for the label.
fun angle: Float `{
- return gtk_label_get_angle(recv);
+ return gtk_label_get_angle(self);
`}
end
`}
fun pixel_size: Int `{
- return gtk_image_get_pixel_size(recv);
+ return gtk_image_get_pixel_size(self);
`}
fun pixel_size=(size: Int) `{
- gtk_image_set_pixel_size(recv, size);
+ gtk_image_set_pixel_size(self, size);
`}
fun clear `{
- gtk_image_clear(recv);
+ gtk_image_clear(self);
`}
end
`}
fun set(arrow_type: GtkArrowType, shadow_type: GtkShadowType) `{
- gtk_arrow_set(recv, arrow_type, shadow_type);
+ gtk_arrow_set(self, arrow_type, shadow_type);
`}
end
`}
fun text: String `{
- return NativeString_to_s((char *)gtk_button_get_label(recv));
+ return NativeString_to_s((char *)gtk_button_get_label(self));
`}
fun text=(value: String) import String.to_cstring `{
- gtk_button_set_label(recv, String_to_cstring(value));
+ gtk_button_set_label(self, String_to_cstring(value));
`}
fun on_click(to_call: GtkCallable, user_data: nullable Object) do
`}
fun expanded: Bool `{
- return gtk_expander_get_expanded(recv);
+ return gtk_expander_get_expanded(self);
`}
fun expanded=(is_expanded: Bool) `{
- gtk_expander_set_expanded(recv, is_expanded);
+ gtk_expander_set_expanded(self, is_expanded);
`}
fun spacing: Int `{
- return gtk_expander_get_spacing(recv);
+ return gtk_expander_get_spacing(self);
`}
fun spacing=(pixels: Int) `{
- gtk_expander_set_spacing(recv, pixels);
+ gtk_expander_set_spacing(self, pixels);
`}
fun label_text: String `{
- return NativeString_to_s((char *)gtk_expander_get_label(recv));
+ return NativeString_to_s((char *)gtk_expander_get_label(self));
`}
fun label_text=(lbl: String) import String.to_cstring `{
- gtk_expander_set_label(recv, String_to_cstring(lbl));
+ gtk_expander_set_label(self, String_to_cstring(lbl));
`}
fun use_underline: Bool `{
- return gtk_expander_get_use_underline(recv);
+ return gtk_expander_get_use_underline(self);
`}
fun use_underline=(used: Bool) `{
- gtk_expander_set_use_underline(recv, used);
+ gtk_expander_set_use_underline(self, used);
`}
fun use_markup: Bool `{
- return gtk_expander_get_use_markup(recv);
+ return gtk_expander_get_use_markup(self);
`}
fun use_markup=(used: Bool) `{
- gtk_expander_set_use_markup(recv, used);
+ gtk_expander_set_use_markup(self, used);
`}
fun label_widget: GtkWidget `{
- return gtk_expander_get_label_widget(recv);
+ return gtk_expander_get_label_widget(self);
`}
fun label_widget=(widget: GtkWidget) `{
- gtk_expander_set_label_widget(recv, widget);
+ gtk_expander_set_label_widget(self, widget);
`}
fun label_fill: Bool `{
- return gtk_expander_get_label_fill(recv);
+ return gtk_expander_get_label_fill(self);
`}
fun label_fill=(fill: Bool) `{
- gtk_expander_set_label_fill(recv, fill);
+ gtk_expander_set_label_fill(self, fill);
`}
fun resize_toplevel: Bool `{
- return gtk_expander_get_resize_toplevel(recv);
+ return gtk_expander_get_resize_toplevel(self);
`}
fun resize_toplevel=(resize: Bool) `{
- gtk_expander_set_resize_toplevel(recv, resize);
+ gtk_expander_set_resize_toplevel(self, resize);
`}
end
`}
fun wrap_width: Int `{
- return gtk_combo_box_get_wrap_width(recv);
+ return gtk_combo_box_get_wrap_width(self);
`}
fun wrap_width=(width: Int) `{
- gtk_combo_box_set_wrap_width(recv, width);
+ gtk_combo_box_set_wrap_width(self, width);
`}
fun row_span_col: Int `{
- return gtk_combo_box_get_row_span_column(recv);
+ return gtk_combo_box_get_row_span_column(self);
`}
fun row_span_col=(row_span: Int) `{
- gtk_combo_box_set_row_span_column(recv, row_span);
+ gtk_combo_box_set_row_span_column(self, row_span);
`}
fun col_span_col: Int `{
- return gtk_combo_box_get_column_span_column(recv);
+ return gtk_combo_box_get_column_span_column(self);
`}
fun col_span_col=(col_span: Int) `{
- gtk_combo_box_set_column_span_column(recv, col_span);
+ gtk_combo_box_set_column_span_column(self, col_span);
`}
fun active_item: Int `{
- return gtk_combo_box_get_active(recv);
+ return gtk_combo_box_get_active(self);
`}
fun active_item=(active: Int) `{
- gtk_combo_box_set_active(recv, active);
+ gtk_combo_box_set_active(self, active);
`}
fun column_id: Int `{
- return gtk_combo_box_get_id_column(recv);
+ return gtk_combo_box_get_id_column(self);
`}
fun column_id=(id_column: Int) `{
- gtk_combo_box_set_id_column(recv, id_column);
+ gtk_combo_box_set_id_column(self, id_column);
`}
fun active_id: String `{
- return NativeString_to_s((char *)gtk_combo_box_get_active_id(recv));
+ return NativeString_to_s((char *)gtk_combo_box_get_active_id(self));
`}
fun active_id=(id_active: String) import String.to_cstring `{
- gtk_combo_box_set_active_id(recv, String_to_cstring(id_active));
+ gtk_combo_box_set_active_id(self, String_to_cstring(id_active));
`}
fun model: GtkTreeModel `{
- return gtk_combo_box_get_model(recv);
+ return gtk_combo_box_get_model(self);
`}
fun model=(model: GtkTreeModel) `{
- gtk_combo_box_set_model(recv, model);
+ gtk_combo_box_set_model(self, model);
`}
fun popup `{
- gtk_combo_box_popup(recv);
+ gtk_combo_box_popup(self);
`}
fun popdown `{
- gtk_combo_box_popdown(recv);
+ gtk_combo_box_popdown(self);
`}
fun title: String `{
- return NativeString_to_s((char *)gtk_combo_box_get_title(recv));
+ return NativeString_to_s((char *)gtk_combo_box_get_title(self));
`}
fun title=(t: String) import String.to_cstring `{
- gtk_combo_box_set_title(recv, String_to_cstring(t));
+ gtk_combo_box_set_title(self, String_to_cstring(t));
`}
fun has_entry: Bool `{
- return gtk_combo_box_get_has_entry(recv);
+ return gtk_combo_box_get_has_entry(self);
`}
fun with_fixed: Bool `{
- return gtk_combo_box_get_popup_fixed_width(recv);
+ return gtk_combo_box_get_popup_fixed_width(self);
`}
fun with_fixed=(fixed: Bool) `{
- gtk_combo_box_set_popup_fixed_width(recv, fixed);
+ gtk_combo_box_set_popup_fixed_width(self, fixed);
`}
end
`}
fun start `{
- return gtk_spinner_start(recv);
+ return gtk_spinner_start(self);
`}
fun stop `{
- return gtk_spinner_stop(recv);
+ return gtk_spinner_stop(self);
`}
end
`}
fun active: Bool `{
- return gtk_switch_get_active(recv);
+ return gtk_switch_get_active(self);
`}
fun active=(is_active: Bool) `{
- return gtk_switch_set_active(recv, is_active);
+ return gtk_switch_set_active(self, is_active);
`}
end
`}
fun set (xalign: Float, yalign: Float, xscale: Float, yscale: Float) `{
- gtk_alignment_set(recv, xalign, yalign, xscale, yscale);
+ gtk_alignment_set(self, xalign, yalign, xscale, yscale);
`}
end
`}
fun run `{
- gtk_dialog_run(recv);
+ gtk_dialog_run(self);
`}
end
`}
fun program_name: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_program_name(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_program_name(self));
`}
fun program_name=(name: String) import String.to_cstring `{
- gtk_about_dialog_set_program_name(recv, String_to_cstring(name));
+ gtk_about_dialog_set_program_name(self, String_to_cstring(name));
`}
fun version: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_version(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_version(self));
`}
fun version=(v: String) import String.to_cstring `{
- gtk_about_dialog_set_version(recv, String_to_cstring(v));
+ gtk_about_dialog_set_version(self, String_to_cstring(v));
`}
fun copyright: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_copyright(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_copyright(self));
`}
fun copyright=(c: String) import String.to_cstring `{
- gtk_about_dialog_set_copyright(recv, String_to_cstring(c));
+ gtk_about_dialog_set_copyright(self, String_to_cstring(c));
`}
fun comments: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_comments(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_comments(self));
`}
fun comments=(com: String) import String.to_cstring `{
- gtk_about_dialog_set_comments(recv, String_to_cstring(com));
+ gtk_about_dialog_set_comments(self, String_to_cstring(com));
`}
fun license: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_license(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_license(self));
`}
fun license=(li: String) import String.to_cstring `{
- gtk_about_dialog_set_license(recv, String_to_cstring(li));
+ gtk_about_dialog_set_license(self, String_to_cstring(li));
`}
# license_type
fun website: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_about_dialog_get_website(recv));
+ return NativeString_to_s((char *)gtk_about_dialog_get_website(self));
`}
fun website=(link: String) import String.to_cstring `{
- gtk_about_dialog_set_website(recv, String_to_cstring(link));
+ gtk_about_dialog_set_website(self, String_to_cstring(link));
`}
fun website_label: String import NativeString.to_s `{
- return NativeString_to_s((char *) gtk_about_dialog_get_website_label(recv));
+ return NativeString_to_s((char *) gtk_about_dialog_get_website_label(self));
`}
fun website_label=(link_label: String) import String.to_cstring `{
- gtk_about_dialog_set_website_label(recv, String_to_cstring(link_label));
+ gtk_about_dialog_set_website_label(self, String_to_cstring(link_label));
`}
# TODO
# fun authors: String`{
- # return NativeString_to_s(gtk_about_dialog_get_authors(recv));
+ # return NativeString_to_s(gtk_about_dialog_get_authors(self));
# `}
# TODO
# fun authors=(authors_list: String) import String.to_cstring`{
- # gtk_about_dialog_set_authors(recv, String_to_cstring(authors_list));
+ # gtk_about_dialog_set_authors(self, String_to_cstring(authors_list));
# `}
fun show_about_dialog(parent: GtkWindow, params: String)
parent, flags, String_to_cstring(content_type));
`}
- fun widget: GtkWidget `{ return gtk_app_chooser_dialog_get_widget(recv); `}
+ fun widget: GtkWidget `{ return gtk_app_chooser_dialog_get_widget(self); `}
fun heading: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_app_chooser_dialog_get_heading(recv));
+ return NativeString_to_s((char *)gtk_app_chooser_dialog_get_heading(self));
`}
fun heading=(text: String) import String.to_cstring `{
- gtk_app_chooser_dialog_set_heading(recv, String_to_cstring(text));
+ gtk_app_chooser_dialog_set_heading(self, String_to_cstring(text));
`}
end
`}
fun month=(month: Int, year: Int) `{
- gtk_calendar_select_month(recv, month, year);
+ gtk_calendar_select_month(self, month, year);
`}
fun day=(day: Int) `{
- gtk_calendar_select_day(recv, day);
+ gtk_calendar_select_day(self, day);
`}
fun mark_day(day: Int) `{
- gtk_calendar_mark_day(recv, day);
+ gtk_calendar_mark_day(self, day);
`}
fun unmark_day(day: Int) `{
- gtk_calendar_unmark_day(recv, day);
+ gtk_calendar_unmark_day(self, day);
`}
fun is_marked(day: Int): Bool `{
- return gtk_calendar_get_day_is_marked(recv, day);
+ return gtk_calendar_get_day_is_marked(self, day);
`}
fun clear_marks `{
- gtk_calendar_clear_marks(recv);
+ gtk_calendar_clear_marks(self);
`}
fun display_options: GtkCalendarDisplayOptions `{
- return gtk_calendar_get_display_options(recv);
+ return gtk_calendar_get_display_options(self);
`}
fun display_options=(options: GtkCalendarDisplayOptions) `{
- gtk_calendar_set_display_options(recv, options);
+ gtk_calendar_set_display_options(self, options);
`}
# date en nit...
`}
fun pulse `{
- gtk_progress_bar_pulse(recv);
+ gtk_progress_bar_pulse(self);
`}
fun pulse_step: Float `{
- return gtk_progress_bar_get_pulse_step(recv);
+ return gtk_progress_bar_get_pulse_step(self);
`}
fun pulse_step=(step: Float) `{
- gtk_progress_bar_set_pulse_step(recv, step);
+ gtk_progress_bar_set_pulse_step(self, step);
`}
fun fraction: Float `{
- return gtk_progress_bar_get_fraction(recv);
+ return gtk_progress_bar_get_fraction(self);
`}
fun fraction=(fraction: Float) `{
- gtk_progress_bar_set_fraction(recv, fraction);
+ gtk_progress_bar_set_fraction(self, fraction);
`}
fun inverted: Bool `{
- return gtk_progress_bar_get_inverted(recv);
+ return gtk_progress_bar_get_inverted(self);
`}
fun inverted=(is_inverted: Bool) `{
- gtk_progress_bar_set_inverted(recv, is_inverted);
+ gtk_progress_bar_set_inverted(self, is_inverted);
`}
fun show_text: Bool `{
- return gtk_progress_bar_get_show_text(recv);
+ return gtk_progress_bar_get_show_text(self);
`}
fun show_text=(show: Bool) `{
- gtk_progress_bar_set_show_text(recv, show);
+ gtk_progress_bar_set_show_text(self, show);
`}
fun text: String import NativeString.to_s `{
- return NativeString_to_s((char *)gtk_progress_bar_get_text(recv));
+ return NativeString_to_s((char *)gtk_progress_bar_get_text(self));
`}
fun text=(value: String) import String.to_cstring `{
- gtk_progress_bar_set_text(recv, String_to_cstring(value));
+ gtk_progress_bar_set_text(self, String_to_cstring(value));
`}
fun ellipsize is abstract
`}
# fun color_selection: `{
- # return gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(recv));
+ # return gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(self));
# `}
# fun color: Float `{
- # return gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(recv));
+ # return gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(self));
# `}
end
`}
fun configure (adjustment: GtkAdjustment, climb_rate: Float, digits: Int) `{
- gtk_spin_button_configure(recv, adjustment, climb_rate, digits);
+ gtk_spin_button_configure(self, adjustment, climb_rate, digits);
`}
fun adjustment: GtkAdjustment `{
- return gtk_spin_button_get_adjustment(recv);
+ return gtk_spin_button_get_adjustment(self);
`}
fun adjustment=(value: GtkAdjustment) `{
- gtk_spin_button_set_adjustment(recv, value);
+ gtk_spin_button_set_adjustment(self, value);
`}
fun digits: Int `{
- return gtk_spin_button_get_digits(recv);
+ return gtk_spin_button_get_digits(self);
`}
fun digits=(nb_digits: Int) `{
- gtk_spin_button_set_digits(recv, nb_digits);
+ gtk_spin_button_set_digits(self, nb_digits);
`}
fun value: Float `{
- return gtk_spin_button_get_value(recv);
+ return gtk_spin_button_get_value(self);
`}
fun val=(val: Float) `{
- gtk_spin_button_set_value(recv, val);
+ gtk_spin_button_set_value(self, val);
`}
fun spin(direction: GtkSpinType, increment: Float)`{
- gtk_spin_button_spin(recv, direction, increment);
+ gtk_spin_button_spin(self, direction, increment);
`}
end
#
# Can be used by on-screen keyboards and other input methods to adjust their behaviour.
fun input_purpose: GtkInputPurpose `{
- return gtk_entry_get_input_purpose(recv);
+ return gtk_entry_get_input_purpose(self);
`}
# Input purpose, tweaks the behavior of this widget
#
# Can be used by on-screen keyboards and other input methods to adjust their behaviour.
fun input_purpose=(purpose: GtkInputPurpose) `{
- gtk_entry_set_input_purpose(recv, purpose);
+ gtk_entry_set_input_purpose(self, purpose);
`}
end
redef class GtkWidget
# Get the visibility of the widget, check if it's parents are visible too
fun visible: Bool `{
- return gtk_widget_is_visible(recv);
+ return gtk_widget_is_visible(self);
`}
end
# Register `self` globally in C so it can be retrieved from iOS callbacks
private fun register_globally in "ObjC" `{
- App_incr_ref(recv);
- app_nit_ios_app = recv;
+ App_incr_ref(self);
+ app_nit_ios_app = self;
`}
# Entry point to the iOS framework
NSLog(@"Hello World!");
// Display "Hello world!" on the screen
- recv.window = [[UIWindow alloc] initWithFrame:
+ self.window = [[UIWindow alloc] initWithFrame:
[[UIScreen mainScreen] bounds]];
- recv.window.backgroundColor = [UIColor whiteColor];
+ self.window.backgroundColor = [UIColor whiteColor];
UILabel *label = [[UILabel alloc] init];
label.text = @"Hello World!";
label.center = CGPointMake(100, 100);
[label sizeToFit];
- [recv.window addSubview: label];
- [recv.window makeKeyAndVisible];
+ [self.window addSubview: label];
+ [self.window makeKeyAndVisible];
return YES;
`}
# Get a new array of the given `size`
new(size: Int) in "Java" `{ return new float[(int)size]; `}
- redef fun [](i) in "Java" `{ return (double)recv[(int)i]; `}
+ redef fun [](i) in "Java" `{ return (double)self[(int)i]; `}
- redef fun []=(i, e) in "Java" `{ recv[(int)i] = (float)e; `}
+ redef fun []=(i, e) in "Java" `{ self[(int)i] = (float)e; `}
- redef fun length in "Java" `{ return recv.length; `}
+ redef fun length in "Java" `{ return self.length; `}
end
# Java primitive array `double[]`
# Get a new array of the given `size`
new(size: Int) in "Java" `{ return new double[(int)size]; `}
- redef fun [](i) in "Java" `{ return recv[(int)i]; `}
+ redef fun [](i) in "Java" `{ return self[(int)i]; `}
- redef fun []=(i, e) in "Java" `{ recv[(int)i] = (float)e; `}
+ redef fun []=(i, e) in "Java" `{ self[(int)i] = (float)e; `}
- redef fun length in "Java" `{ return recv.length; `}
+ redef fun length in "Java" `{ return self.length; `}
end
# Java primitive array `Object[]`
# Get a new array of the given `size`
new(size: Int) in "Java" `{ return new Object[(int)size]; `}
- redef fun [](i) in "Java" `{ return recv[(int)i]; `}
+ redef fun [](i) in "Java" `{ return self[(int)i]; `}
- redef fun []=(i, e) in "Java" `{ recv[(int)i] = e; `}
+ redef fun []=(i, e) in "Java" `{ self[(int)i] = e; `}
- redef fun length in "Java" `{ return recv.length; `}
+ redef fun length in "Java" `{ return self.length; `}
end
# TODO other primitive arrays:
extern class NativeFile in "Java" `{ java.io.File `}
super JavaObject
- fun can_execute: Bool in "Java" `{ return recv.canExecute(); `}
- fun can_read: Bool in "Java" `{ return recv.canRead(); `}
- fun can_write: Bool in "Java" `{ return recv.canWrite(); `}
+ fun can_execute: Bool in "Java" `{ return self.canExecute(); `}
+ fun can_read: Bool in "Java" `{ return self.canRead(); `}
+ fun can_write: Bool in "Java" `{ return self.canWrite(); `}
fun create_file: Bool in "Java" `{
try {
- return recv.createNewFile();
+ return self.createNewFile();
}catch(IOException e){
e.printStackTrace();
return false;
}
`}
- fun delete: Bool in "Java" `{ return recv.delete(); `}
- fun delete_on_exit in "Java" `{ recv.deleteOnExit(); `}
- fun exists: Bool in "Java" `{ return recv.exists(); `}
- fun absolute_file: NativeFile in "Java" `{ return recv.getAbsoluteFile(); `}
- fun absolute_path: JavaString in "Java" `{ return recv.getAbsolutePath(); `}
+ fun delete: Bool in "Java" `{ return self.delete(); `}
+ fun delete_on_exit in "Java" `{ self.deleteOnExit(); `}
+ fun exists: Bool in "Java" `{ return self.exists(); `}
+ fun absolute_file: NativeFile in "Java" `{ return self.getAbsoluteFile(); `}
+ fun absolute_path: JavaString in "Java" `{ return self.getAbsolutePath(); `}
fun canonical_file: NativeFile in "Java" `{
try {
- return recv.getCanonicalFile();
+ return self.getCanonicalFile();
}catch(IOException e){
e.printStackTrace();
return null;
}
`}
- fun free_space: Int in "Java" `{ return (int)recv.getFreeSpace(); `}
- fun name: JavaString in "Java" `{ return recv.getName(); `}
- fun parent: JavaString in "Java" `{ return recv.getParent(); `}
- fun parent_file: NativeFile in "Java" `{ return recv.getParentFile(); `}
- fun path: JavaString in "Java" `{ return recv.getPath(); `}
- fun total_space: Int in "Java" `{ return (int)recv.getTotalSpace(); `}
- fun usable_space: Int in "Java" `{ return (int)recv.getUsableSpace(); `}
- fun absolute: Bool in "Java" `{ return recv.isAbsolute(); `}
- fun is_directory: Bool in "Java" `{ return recv.isDirectory(); `}
- fun is_file: Bool in "Java" `{ return recv.isFile(); `}
- fun is_hidden: Bool in "Java" `{ return recv.isHidden(); `}
- fun last_modified: Int in "Java" `{ return (int)recv.lastModified(); `}
- fun length: Int in "Java" `{ return (int)recv.length(); `}
- fun set_readable(r: Bool, owner_only: Bool): Bool in "Java" `{ return recv.setReadable(r, owner_only); `}
- fun set_writable(w: Bool, owner_only: Bool): Bool in "Java" `{ return recv.setWritable(w, owner_only); `}
+ fun free_space: Int in "Java" `{ return (int)self.getFreeSpace(); `}
+ fun name: JavaString in "Java" `{ return self.getName(); `}
+ fun parent: JavaString in "Java" `{ return self.getParent(); `}
+ fun parent_file: NativeFile in "Java" `{ return self.getParentFile(); `}
+ fun path: JavaString in "Java" `{ return self.getPath(); `}
+ fun total_space: Int in "Java" `{ return (int)self.getTotalSpace(); `}
+ fun usable_space: Int in "Java" `{ return (int)self.getUsableSpace(); `}
+ fun absolute: Bool in "Java" `{ return self.isAbsolute(); `}
+ fun is_directory: Bool in "Java" `{ return self.isDirectory(); `}
+ fun is_file: Bool in "Java" `{ return self.isFile(); `}
+ fun is_hidden: Bool in "Java" `{ return self.isHidden(); `}
+ fun last_modified: Int in "Java" `{ return (int)self.lastModified(); `}
+ fun length: Int in "Java" `{ return (int)self.length(); `}
+ fun set_readable(r: Bool, owner_only: Bool): Bool in "Java" `{ return self.setReadable(r, owner_only); `}
+ fun set_writable(w: Bool, owner_only: Bool): Bool in "Java" `{ return self.setWritable(w, owner_only); `}
end
extern class NativeFileInputStream in "Java" `{ java.io.FileInputStream `}
fun available: Int in "Java" `{
try {
- return recv.available();
+ return self.available();
}catch(IOException e){
e.printStackTrace();
return -1;
`}
fun close in "Java" `{
try {
- recv.close();
+ self.close();
}catch(IOException e){
e.printStackTrace();
}
`}
fun read: Int in "Java" `{
try {
- return recv.read();
+ return self.read();
}catch(IOException e){
e.printStackTrace();
return -1;
`}
fun skip(byte_count: Int): Int in "Java" `{
try {
- return (int)recv.skip(byte_count);
+ return (int)self.skip(byte_count);
}catch(IOException e){
e.printStackTrace();
return -1;
fun close in "Java" `{
try {
- recv.close();
+ self.close();
}catch(IOException e){
e.printStackTrace();
}
`}
fun write(one_byte: Int) in "Java" `{
try {
- recv.write((byte)one_byte);
+ self.write((byte)one_byte);
}catch(IOException e){
e.printStackTrace();
}
`}
fun flush in "Java" `{
try {
- recv.flush();
+ self.flush();
}catch(IOException e){
e.printStackTrace();
}
fun sync in "Java" `{
try{
- recv.sync();
+ self.sync();
}catch(SyncFailedException e){
e.printStackTrace();
}
`}
- fun valid: Bool in "Java" `{ return recv.valid(); `}
+ fun valid: Bool in "Java" `{ return self.valid(); `}
end
extern class NativeInputStream in "Java" `{ java.io.InputStream `}
fun available: Int in "Java" `{
try {
- return recv.available();
+ return self.available();
}catch(IOException e){
e.printStackTrace();
return -1;
fun close in "Java" `{
try {
- recv.close();
+ self.close();
}catch(IOException e){
e.printStackTrace();
}
# Get a Java class by its name from the current `jni_env`
fun load_jclass(name: NativeString): JClass import jni_env `{
- JNIEnv *nit_ffi_jni_env = Sys_jni_env(recv);
+ JNIEnv *nit_ffi_jni_env = Sys_jni_env(self);
// retrieve the implementation Java class
jclass java_class = (*nit_ffi_jni_env)->FindClass(nit_ffi_jni_env, name);
# Get the string from Java and copy it to Nit memory
fun to_cstring: NativeString import sys, Sys.jni_env `{
- Sys sys = JavaString_sys(recv);
+ Sys sys = JavaString_sys(self);
JNIEnv *env = Sys_jni_env(sys);
// Get the data from Java
- const jbyte *java_cstr = (char*)(*env)->GetStringUTFChars(env, recv, NULL);
- jsize len = (*env)->GetStringUTFLength(env, recv);
+ const jbyte *java_cstr = (char*)(*env)->GetStringUTFChars(env, self, NULL);
+ jsize len = (*env)->GetStringUTFLength(env, self);
// Copy it in control of Nit
char *nit_cstr = (char*)malloc(len+1);
nit_cstr[len] = '\0';
// Free JNI ref and return
- (*env)->ReleaseStringUTFChars(env, recv, java_cstr);
+ (*env)->ReleaseStringUTFChars(env, self, java_cstr);
return nit_cstr;
`}
# This instance is only valid until the next execution of Java code.
# You can use `new_local_ref` to keep it longer.
fun to_java_string: JavaString import sys, Sys.jni_env `{
- Sys sys = JavaString_sys(recv);
+ Sys sys = JavaString_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewStringUTF(env, recv);
+ return (*env)->NewStringUTF(env, self);
`}
end
# You must use a global reference when keeping a Java object
# across execution of Java code, per JNI specification.
fun new_global_ref: SELF import sys, Sys.jni_env `{
- Sys sys = JavaObject_sys(recv);
+ Sys sys = JavaObject_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- return (*env)->NewGlobalRef(env, recv);
+ return (*env)->NewGlobalRef(env, self);
`}
# Delete this global reference
fun delete_global_ref import sys, Sys.jni_env `{
- Sys sys = JavaObject_sys(recv);
+ Sys sys = JavaObject_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- (*env)->DeleteGlobalRef(env, recv);
+ (*env)->DeleteGlobalRef(env, self);
`}
# Delete this local reference
fun delete_local_ref import sys, Sys.jni_env `{
- Sys sys = JavaObject_sys(recv);
+ Sys sys = JavaObject_sys(self);
JNIEnv *env = Sys_jni_env(sys);
- (*env)->DeleteLocalRef(env, recv);
+ (*env)->DeleteLocalRef(env, self);
`}
# Pops the current local reference frame and return a valid reference to self
end
private fun pop_from_local_frame_with_env(jni_env: JniEnv): SELF `{
- return (*jni_env)->PopLocalFrame(jni_env, recv);
+ return (*jni_env)->PopLocalFrame(jni_env, self);
`}
# Is `self` null in Java?
# the return of all extern methods implemented in Java to ensure the value
# is not a Java null. In case it is, you should replace it by a normal Nit
# `null`.
- fun is_java_null: Bool in "Java" `{ return recv == null; `}
+ fun is_java_null: Bool in "Java" `{ return self == null; `}
# `JavaString` representation of `self` using Java's `toString`
- fun to_java_string: JavaString in "Java" `{ return recv.toString(); `}
+ fun to_java_string: JavaString in "Java" `{ return self.toString(); `}
# Use Java's `toString` for any `JavaObject`
redef fun to_s
# assert "123".to_json_value.to_s == "123"
# assert "true".to_json_value.to_s == "true"
# assert "[1, 2, 3]".to_json_value.to_s == "123"
- redef fun to_s: String
- do
+ redef fun to_s do
if value == null then return "null"
return value.to_s
end
# ~~~
module serialization
-import ::serialization
+import ::serialization::caching
private import ::serialization::engine_tools
private import static
# Serializer of Nit objects to Json string.
class JsonSerializer
- super Serializer
+ super CachingSerializer
# Target writing stream
var stream: Writer
redef fun serialize_reference(object)
do
- if not plain_json and refs_map.has_key(object) then
+ if not plain_json and cache.has_object(object) then
# if already serialized, add local reference
- var id = ref_id_for(object)
+ var id = cache.id_for(object)
stream.write "\{\"__kind\": \"ref\", \"__id\": "
stream.write id.to_s
stream.write "\}"
serialize object
end
end
-
- # Map of references to already serialized objects.
- private var refs_map = new StrictHashMap[Serializable,Int]
-
- # Get the internal serialized reference for this `object`.
- private fun ref_id_for(object: Serializable): Int
- do
- if refs_map.has_key(object) then
- return refs_map[object]
- else
- var id = refs_map.length
- refs_map[object] = id
- return id
- end
- end
end
# Deserializer from a Json string.
class JsonDeserializer
- super Deserializer
+ super CachingDeserializer
# Json text to deserialize from.
private var text: Text
# Depth-first path in the serialized object tree.
private var path = new Array[JsonObject]
- # Map of references to already deserialized objects.
- private var id_to_object = new StrictHashMap[Int, Object]
-
# Last encountered object reference id.
#
# See `id_to_object`.
do
var id = just_opened_id
if id == null then return # Register `new_object` only once
- id_to_object[id] = new_object
+ cache[id] = new_object
end
# Convert from simple Json object to Nit object
var id = object["__id"]
assert id isa Int
- assert id_to_object.has_key(id)
- return id_to_object[id]
+ assert cache.has_id(id)
+ return cache.object_for(id)
end
# obj?
var class_name = object["__class"]
assert class_name isa String
- assert not id_to_object.has_key(id) else print "Error: Object with id '{id}' of {class_name} is deserialized twice."
+ assert not cache.has_id(id) else print "Error: Object with id '{id}' of {class_name} is deserialized twice."
# advance on path
path.push object
redef class Serializable
private fun serialize_to_json(v: JsonSerializer)
do
- var id = v.ref_id_for(self)
+ var id = v.cache.new_id_for(self)
v.stream.write "\{"
if not v.plain_json then
v.stream.write "\"__kind\": \"obj\", \"__id\": "
do
# Register as pseudo object
if not v.plain_json then
- var id = v.ref_id_for(self)
+ var id = v.cache.new_id_for(self)
v.stream.write """{"__kind": "obj", "__id": """
v.stream.write id.to_s
v.stream.write """, "__class": """"
redef init from_deserializer(v: Deserializer)
do
+ super
if v isa JsonDeserializer then
v.notify_of_creation self
init
redef fun serialize_to_json(v)
do
# Register as pseudo object
- var id = v.ref_id_for(self)
+ var id = v.cache.new_id_for(self)
if v.plain_json then
v.stream.write "\{"
# Instantiate a new `Array` from its serialized representation.
redef init from_deserializer(v: Deserializer)
do
- init
+ super
if v isa JsonDeserializer then
v.notify_of_creation self
+ init
var length = v.deserialize_attribute("__length").as(Int)
var keys = v.path.last["__keys"].as(SequenceRead[nullable Object])
# Unavailable on Android, where you cannot instanciate a new JVM.
fun set_default `{
#ifndef ANDROID
- JNI_GetDefaultJavaVMInitArgs(recv);
+ JNI_GetDefaultJavaVMInitArgs(self);
#endif
`}
- fun version: Int `{ return recv->version; `}
- fun version=(v: Int) `{ recv->version = v; `}
+ fun version: Int `{ return self->version; `}
+ fun version=(v: Int) `{ self->version = v; `}
- fun options: JavaVMOptionArray `{ return recv->options; `}
- fun options=(v: JavaVMOptionArray) `{ recv->options = v; `}
+ fun options: JavaVMOptionArray `{ return self->options; `}
+ fun options=(v: JavaVMOptionArray) `{ self->options = v; `}
- fun n_options: Int `{ return recv->nOptions; `}
- fun n_options=(v: Int) `{ recv->nOptions = v; `}
+ fun n_options: Int `{ return self->nOptions; `}
+ fun n_options=(v: Int) `{ self->nOptions = v; `}
end
private extern class JavaVMOption `{ JavaVMOption* `}
fun string: String import NativeString.to_s `{
- return NativeString_to_s((char*)recv->optionString);
+ return NativeString_to_s((char*)self->optionString);
`}
fun string=(v: String) import String.to_cstring `{
- recv->optionString = String_to_cstring(v);
+ self->optionString = String_to_cstring(v);
`}
fun extra_info: String import NativeString.to_s `{
- return NativeString_to_s((char*)recv->extraInfo);
+ return NativeString_to_s((char*)self->extraInfo);
`}
fun extra_info=(v: String) import String.to_cstring `{
- recv->extraInfo = String_to_cstring(v);
+ self->extraInfo = String_to_cstring(v);
`}
end
private extern class JavaVMOptionArray `{ JavaVMOption* `}
new(size: Int) `{ return (JavaVMOption*)malloc(sizeof(JavaVMOption)*size); `}
- fun [](i: Int): JavaVMOption `{ return recv+i; `}
+ fun [](i: Int): JavaVMOption `{ return self+i; `}
end
# Represents a jni JavaVM
end
fun destroy `{
- (*recv)->DestroyJavaVM(recv);
+ (*self)->DestroyJavaVM(self);
`}
fun env: JniEnv import jni_error `{
JNIEnv *env;
- int res = (*recv)->GetEnv(recv, (void **)&env, JNI_VERSION_1_6);
+ int res = (*self)->GetEnv(self, (void **)&env, JNI_VERSION_1_6);
if (res != JNI_OK) {
JavaVM_jni_error(NULL, "Could not get JNIEnv from Java VM", res);
return NULL;
JNIEnv *env;
#ifdef ANDROID
// the signature is different (better actually) on Android
- int res = (*recv)->AttachCurrentThread(recv, &env, NULL);
+ int res = (*self)->AttachCurrentThread(self, &env, NULL);
#else
- int res = (*recv)->AttachCurrentThread(recv, (void**)&env, NULL);
+ int res = (*self)->AttachCurrentThread(self, (void**)&env, NULL);
#endif
if (res != JNI_OK) {
JavaVM_jni_error(NULL, "Could not attach current thread to Java VM", res);
# Get a class object from its fully-qualified name or null if the class cannot be found
fun find_class(class_name : String): JClass import String.to_cstring `{
- return (*recv)->FindClass(recv,String_to_cstring(class_name));
+ return (*self)->FindClass(self,String_to_cstring(class_name));
`}
# Return the method id for an instance of a class or interface
# The method is determined by its name and signature
# To obtain the method ID of a constructor, supply "<init>" as the method name and "void(V)" as the return type
fun get_method_id(clazz : JClass, name : String, signature : String): JMethodID import String.to_cstring `{
- return (*recv)->GetMethodID(recv, clazz, String_to_cstring(name), String_to_cstring(signature));
+ return (*self)->GetMethodID(self, clazz, String_to_cstring(name), String_to_cstring(signature));
`}
# Construct a new Java object from the `clazz`, using the constructor ̀ method_id`
fun new_object(clazz: JClass, method_id: JMethodID): JavaObject `{
- return (*recv)->NewObject(recv, clazz, method_id);
+ return (*self)->NewObject(self, clazz, method_id);
`}
# Return the JClass of `obj`
fun get_object_class(obj: JavaObject): JClass `{
- return (*recv)->GetObjectClass(recv, obj);
+ return (*self)->GetObjectClass(self, obj);
`}
# Registers native methods with the class specified by the `clazz` argument
fun register_natives(clazz: JClass, method: JNINativeMethod, n_method : Int): Int `{
- return (*recv)->RegisterNatives(recv, clazz, method, n_method);
+ return (*self)->RegisterNatives(self, clazz, method, n_method);
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments
fun call_void_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]) import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- (*recv)->CallVoidMethodA(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ (*self)->CallVoidMethodA(self, obj, method_id, args_tab);
free(args_tab);
`}
# Call a method on `obj` designed by `method_id` with an array `args` of argument returning a JavaObject
fun call_object_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): JavaObject import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jobject res = (*recv)->CallObjectMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jobject res = (*self)->CallObjectMethod(self, obj, method_id, args_tab);
free(args_tab);
return res;
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Bool
fun call_boolean_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Bool import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jboolean res = (*recv)->CallBooleanMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jboolean res = (*self)->CallBooleanMethod(self, obj, method_id, args_tab);
free(args_tab);
return res;
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Char
fun call_char_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Char import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jchar res = (*recv)->CallCharMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jchar res = (*self)->CallCharMethod(self, obj, method_id, args_tab);
free(args_tab);
return res;
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments returning an Int
fun call_int_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Int import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jint res = (*recv)->CallIntMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jint res = (*self)->CallIntMethod(self, obj, method_id, args_tab);
free(args_tab);
return res;
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a Float
fun call_float_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): Float import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jfloat res = (*recv)->CallFloatMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jfloat res = (*self)->CallFloatMethod(self, obj, method_id, args_tab);
free(args_tab);
return res;
`}
# Call a method on `obj` designed by `method_id` with an array `args` of arguments returning a NativeString
fun call_string_method(obj: JavaObject, method_id: JMethodID, args: nullable Array[nullable Object]): NativeString import convert_args_to_jni `{
- jvalue * args_tab = JniEnv_convert_args_to_jni(recv, args);
- jobject jobj = (*recv)->CallObjectMethod(recv, obj, method_id, args_tab);
+ jvalue * args_tab = JniEnv_convert_args_to_jni(self, args);
+ jobject jobj = (*self)->CallObjectMethod(self, obj, method_id, args_tab);
free(args_tab);
- return (char*)(*recv)->GetStringUTFChars(recv, (jstring)jobj, NULL);
+ return (char*)(*self)->GetStringUTFChars(self, (jstring)jobj, NULL);
`}
private fun convert_args_to_jni(args: nullable Array[nullable Object]): Pointer import Array[nullable Object].as not nullable, Array[nullable Object].[], Array[nullable Object].length, nullable Object.as(Int), nullable Object.as(Char), nullable Object.as(Bool), nullable Object.as(Float), nullable Object.as(JavaObject), nullable Object.as(String), String.to_cstring, String.length `{
} else if(nullable_Object_is_a_String(nullable_obj)){
String val = nullable_Object_as_String(nullable_obj);
char* c = String_to_cstring(val);
- jstring js = (*recv)->NewStringUTF(recv, c);
+ jstring js = (*self)->NewStringUTF(self, c);
c_array[i].l = js;
} else {
fprintf(stderr, "NOT YET SUPPORTED: nit objects are not supported\n");
# Returns the field ID for an instance field of a class. The field is specified by its name and signature
fun get_field_id(clazz: JClass, name: String, sign: String): JFieldID import String.to_cstring `{
- return (*recv)->GetFieldID(recv, clazz, String_to_cstring(name), String_to_cstring(sign));
+ return (*self)->GetFieldID(self, clazz, String_to_cstring(name), String_to_cstring(sign));
`}
# returns the value of an instance (nonstatic) field of an object. The field to access is specified by a field ID obtained by calling get_field_id()
fun get_object_field(obj: JavaObject, fieldID: JFieldID): JavaObject `{
- return (*recv)->GetObjectField(recv, obj, fieldID);
+ return (*self)->GetObjectField(self, obj, fieldID);
`}
fun get_boolean_field(obj: JavaObject, fieldID: JFieldID): Bool `{
- return (*recv)->GetBooleanField(recv, obj, fieldID);
+ return (*self)->GetBooleanField(self, obj, fieldID);
`}
fun get_char_field(obj: JavaObject, fieldID: JFieldID): Char `{
- return (*recv)->GetCharField(recv, obj, fieldID);
+ return (*self)->GetCharField(self, obj, fieldID);
`}
fun get_int_field(obj: JavaObject, fieldID: JFieldID): Int `{
- return (*recv)->GetIntField(recv, obj, fieldID);
+ return (*self)->GetIntField(self, obj, fieldID);
`}
fun get_float_field(obj: JavaObject, fieldID: JFieldID): Float `{
- return (*recv)->GetFloatField(recv, obj, fieldID);
+ return (*self)->GetFloatField(self, obj, fieldID);
`}
fun set_object_field(obj: JavaObject, fieldID: JFieldID, value: JavaObject) `{
- (*recv)->SetObjectField(recv, obj, fieldID, value);
+ (*self)->SetObjectField(self, obj, fieldID, value);
`}
fun set_boolean_field(obj: JavaObject, fieldID: JFieldID, value: Bool) `{
- (*recv)->SetBooleanField(recv, obj, fieldID, value);
+ (*self)->SetBooleanField(self, obj, fieldID, value);
`}
fun set_char_field(obj: JavaObject, fieldID: JFieldID, value: Char) `{
- (*recv)->SetCharField(recv, obj, fieldID, value);
+ (*self)->SetCharField(self, obj, fieldID, value);
`}
fun set_int_field(obj: JavaObject, fieldID: JFieldID, value: Int) `{
- (*recv)->SetIntField(recv, obj, fieldID, value);
+ (*self)->SetIntField(self, obj, fieldID, value);
`}
fun set_float_field(obj: JavaObject, fieldID: JFieldID, value: Float) `{
- (*recv)->SetFloatField(recv, obj, fieldID, value);
+ (*self)->SetFloatField(self, obj, fieldID, value);
`}
# Check for pending exception without creating a local reference to the exception object
fun exception_check: Bool `{
- return (*recv)->ExceptionCheck(recv);
+ return (*self)->ExceptionCheck(self);
`}
# Construct an exception object from the specified class with the message specified by `message` and causes that exception to be thrown
fun throw_new(clazz: JClass, message: String): Int import String.to_cstring `{
- return (*recv)->ThrowNew(recv, clazz, String_to_cstring(message));
+ return (*self)->ThrowNew(self, clazz, String_to_cstring(message));
`}
# return the exception if there is one in the process of being thrown, or NULL if no exception is currently being thrown
fun exception_occurred: JavaObject `{
- return (*recv)->ExceptionOccurred(recv);
+ return (*self)->ExceptionOccurred(self);
`}
# prints an exception and backtrace to error channel
fun exception_describe `{
- return (*recv)->ExceptionDescribe(recv);
+ return (*self)->ExceptionDescribe(self);
`}
# clears any exception currently being thrown, has no effect if there is no exception
fun exception_clear `{
- return (*recv)->ExceptionClear(recv);
+ return (*self)->ExceptionClear(self);
`}
# Raise a fatal error
fun fatal_error(msg: String) import String.to_cstring `{
- (*recv)->FatalError(recv, String_to_cstring(msg));
+ (*self)->FatalError(self, String_to_cstring(msg));
`}
# Transform a NIT String into a JavaObject
fun string_to_jobject(string: String): JavaObject `{
- return (*recv)->NewStringUTF(recv, String_to_cstring(string));
+ return (*self)->NewStringUTF(self, String_to_cstring(string));
`}
# Pushes a local reference frame on the JNI stack
fun push_local_frame(capacity: Int): Bool `{
- return (*recv)->PushLocalFrame(recv, capacity);
+ return (*self)->PushLocalFrame(self, capacity);
`}
# Pops the current local reference frame on the JNI stack
#
# Similiar to `JavaObject::pop_from_local_frame` which returns a value.
fun pop_local_frame `{
- (*recv)->PopLocalFrame(recv, NULL);
+ (*self)->PopLocalFrame(self, NULL);
`}
end
# Represents a jni JNINNativeMethod
extern class JNINativeMethod `{ JNINativeMethod* `}
fun name: String import NativeString.to_s `{
- return NativeString_to_s((void*)recv->name);
+ return NativeString_to_s((void*)self->name);
`}
fun name=(name: String) import String.to_cstring `{
- recv->name = String_to_cstring(name);
+ self->name = String_to_cstring(name);
`}
fun signature: String import NativeString.to_s `{
- return NativeString_to_s((void*)recv->signature);
+ return NativeString_to_s((void*)self->signature);
`}
fun signature=(signature: String) import String.to_cstring `{
- recv->signature = String_to_cstring(signature);
+ self->signature = String_to_cstring(signature);
`}
end
extern class JValue `{jvalue`}
fun set_boolean(b: Bool) `{
- recv.z = b;
+ self.z = b;
`}
fun get_boolean:Bool `{
- return recv.z;
+ return self.z;
`}
fun set_char(c: Char)`{
- recv.c = c;
+ self.c = c;
`}
fun get_char: Char `{
- return recv.c;
+ return self.c;
`}
fun set_int(i: Int) `{
- recv.i = i;
+ self.i = i;
`}
fun get_int: Int `{
- return recv.i;
+ return self.i;
`}
fun set_float(f: Float) `{
- recv.f = f;
+ self.f = f;
`}
fun get_float: Float `{
- return recv.f;
+ return self.f;
`}
fun set_jobject(obj: JavaObject) `{
- recv.l = obj;
+ self.l = obj;
`}
fun get_jobject: JavaObject `{
- return recv.l;
+ return self.l;
`}
end
redef class Int
redef fun to_jvalue(env): JValue `{
jvalue value;
- value.i = recv;
+ value.i = self;
return value;
`}
end
redef class Float
redef fun to_jvalue(env): JValue `{
jvalue value;
- value.f = recv;
+ value.f = self;
return value;
`}
end
redef class Bool
redef fun to_jvalue(env): JValue `{
jvalue value;
- value.z = recv;
+ value.z = self;
return value;
`}
end
redef class NativeString
redef fun to_jvalue(env)`{
jvalue value;
- value.l = (*env)->NewStringUTF(env, recv);
+ value.l = (*env)->NewStringUTF(env, self);
return value;
`}
end
#
# This loop will run the event base until either there are no more added
# events, or until something calls `exit_loop`.
- fun dispatch `{ event_base_dispatch(recv); `}
+ fun dispatch `{ event_base_dispatch(self); `}
# Exit the event loop
#
# TODO support timer
- fun exit_loop `{ event_base_loopexit(recv, NULL); `}
+ fun exit_loop `{ event_base_loopexit(self, NULL); `}
# Destroy this instance
- fun destroy `{ event_base_free(recv); `}
+ fun destroy `{ event_base_free(self); `}
end
# Spawned to manage a specific connection
#
# TODO, use polls
class Connection
+ super Writer
+
# Closing this connection has been requested, but may not yet be `closed`
var close_requested = false
var native_buffer_event: NativeBufferEvent
# Close this connection if possible, otherwise mark it to be closed later
- fun close
+ redef fun close
do
var success = native_buffer_event.destroy
close_requested = true
fun event_callback(events: Int) do end
# Write a string to the connection
- fun write(str: String)
+ redef fun write(str)
do
native_buffer_event.write(str.to_cstring, str.length)
end
+ redef fun write_byte(byte) do native_buffer_event.write_byte(byte)
+
# Write a file to the connection
#
# require: `path.file_exists`
extern class NativeBufferEvent `{ struct bufferevent * `}
# Write `length` bytes of `line`
fun write(line: NativeString, length: Int): Int `{
- return bufferevent_write(recv, line, length);
+ return bufferevent_write(self, line, length);
+ `}
+
+ # Write the byte `value`
+ fun write_byte(value: Int): Int `{
+ unsigned char byt = (unsigned char)value;
+ return bufferevent_write(self, &byt, 1);
`}
# Check if we have anything left in our buffers. If so, we set our connection to be closed
# on a callback. Otherwise we close it and free it right away.
fun destroy: Bool `{
- struct evbuffer* out = bufferevent_get_output(recv);
- struct evbuffer* in = bufferevent_get_input(recv);
+ struct evbuffer* out = bufferevent_get_output(self);
+ struct evbuffer* in = bufferevent_get_input(self);
if(evbuffer_get_length(in) > 0 || evbuffer_get_length(out) > 0) {
return 0;
} else {
- bufferevent_free(recv);
+ bufferevent_free(self);
return 1;
}
`}
# The output buffer associated to `self`
- fun output_buffer: OutputNativeEvBuffer `{ return bufferevent_get_output(recv); `}
+ fun output_buffer: OutputNativeEvBuffer `{ return bufferevent_get_output(self); `}
# The input buffer associated to `self`
- fun input_buffer: InputNativeEvBuffer `{ return bufferevent_get_input(recv); `}
+ fun input_buffer: InputNativeEvBuffer `{ return bufferevent_get_input(self); `}
end
# A single buffer
extern class NativeEvBuffer `{ struct evbuffer * `}
# Length of data in this buffer
- fun length: Int `{ return evbuffer_get_length(recv); `}
+ fun length: Int `{ return evbuffer_get_length(self); `}
end
# An input buffer
super NativeEvBuffer
# Empty/clear `length` data from buffer
- fun drain(length: Int) `{ evbuffer_drain(recv, length); `}
+ fun drain(length: Int) `{ evbuffer_drain(self, length); `}
end
# An output buffer
# Add file to buffer
fun add_file(fd, offset, length: Int): Bool `{
- return evbuffer_add_file(recv, fd, offset, length);
+ return evbuffer_add_file(self, fd, offset, length);
`}
end
`}
# Get the `NativeEventBase` associated to `self`
- fun base: NativeEventBase `{ return evconnlistener_get_base(recv); `}
+ fun base: NativeEventBase `{ return evconnlistener_get_base(self); `}
# Callback method on listening error
fun error_callback do
# This file is part of NIT ( http://www.nitlanguage.org ).
+#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
private var allowed_id_chars: Array[Char] = ['-', '_', ':', '.']
end
+
+# Decorator for span elements.
+#
+# InlineDecorator does not decorate things like paragraphs or headers.
+class InlineDecorator
+ super HTMLDecorator
+
+ redef fun add_paragraph(v, block) do v.emit_in block
+ redef fun add_headline(v, block) do v.emit_in block
+
+ redef fun add_code(v, block) do
+ v.add "<code>"
+ v.emit_in block
+ v.add "</code>"
+ end
+end
# Split `input` string into `MDLines` and create a parent `MDBlock` with it.
private fun read_lines(input: String): MDBlock do
- var block = new MDBlock
+ var block = new MDBlock(new MDLocation(1, 1, 1, 1))
var value = new FlatBuffer
var i = 0
+
+ var line_pos = 0
+ var col_pos = 0
+
while i < input.length do
value.clear
var pos = 0
var eol = false
while not eol and i < input.length do
+ col_pos += 1
var c = input[i]
if c == '\n' then
- i += 1
eol = true
else if c == '\t' then
var np = pos + (4 - (pos.bin_and(3)))
value.add ' '
pos += 1
end
- i += 1
else
pos += 1
value.add c
- i += 1
end
+ i += 1
end
+ line_pos += 1
- var line = new MDLine(value.write_to_string)
+ var loc = new MDLocation(line_pos, 1, line_pos, col_pos)
+ var line = new MDLine(loc, value.write_to_string)
var is_link_ref = check_link_ref(line)
# Skip link refs
if not is_link_ref then block.add_line line
+ col_pos = 0
end
return block
end
c2 = ' '
end
+ var loc = text.pos_to_loc(pos)
+
if c == '*' then
if c1 == '*' then
if c0 != ' ' or c2 != ' ' then
- return new TokenStrongStar(pos, c)
+ return new TokenStrongStar(loc, pos, c)
else
- return new TokenEmStar(pos, c)
+ return new TokenEmStar(loc, pos, c)
end
end
if c0 != ' ' or c1 != ' ' then
- return new TokenEmStar(pos, c)
+ return new TokenEmStar(loc, pos, c)
else
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
end
else if c == '_' then
if c1 == '_' then
if c0 != ' ' or c2 != ' 'then
- return new TokenStrongUnderscore(pos, c)
+ return new TokenStrongUnderscore(loc, pos, c)
else
- return new TokenEmUnderscore(pos, c)
+ return new TokenEmUnderscore(loc, pos, c)
end
end
if ext_mode then
if (c0.is_letter or c0.is_digit) and c0 != '_' and
(c1.is_letter or c1.is_digit) then
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
else
- return new TokenEmUnderscore(pos, c)
+ return new TokenEmUnderscore(loc, pos, c)
end
end
if c0 != ' ' or c1 != ' ' then
- return new TokenEmUnderscore(pos, c)
+ return new TokenEmUnderscore(loc, pos, c)
else
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
end
else if c == '!' then
- if c1 == '[' then return new TokenImage(pos, c)
- return new TokenNone(pos, c)
+ if c1 == '[' then return new TokenImage(loc, pos, c)
+ return new TokenNone(loc, pos, c)
else if c == '[' then
- return new TokenLink(pos, c)
+ return new TokenLink(loc, pos, c)
else if c == ']' then
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
else if c == '`' then
if c1 == '`' then
- return new TokenCodeDouble(pos, c)
+ return new TokenCodeDouble(loc, pos, c)
else
- return new TokenCodeSingle(pos, c)
+ return new TokenCodeSingle(loc, pos, c)
end
else if c == '\\' then
if c1 == '\\' or c1 == '[' or c1 == ']' or c1 == '(' or c1 == ')' or c1 == '{' or c1 == '}' or c1 == '#' or c1 == '"' or c1 == '\'' or c1 == '.' or c1 == '<' or c1 == '>' or c1 == '*' or c1 == '+' or c1 == '-' or c1 == '_' or c1 == '!' or c1 == '`' or c1 == '~' or c1 == '^' then
- return new TokenEscape(pos, c)
+ return new TokenEscape(loc, pos, c)
else
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
end
else if c == '<' then
- return new TokenHTML(pos, c)
+ return new TokenHTML(loc, pos, c)
else if c == '&' then
- return new TokenEntity(pos, c)
+ return new TokenEntity(loc, pos, c)
else
if ext_mode then
if c == '~' and c1 == '~' then
- return new TokenStrike(pos, c)
+ return new TokenStrike(loc, pos, c)
end
end
- return new TokenNone(pos, c)
+ return new TokenNone(loc, pos, c)
end
end
private var allowed_id_chars: Array[Char] = ['-', '_', ':', '.']
end
+# Location in a Markdown input.
+class MDLocation
+
+ # Starting line number (starting from 1).
+ var line_start: Int
+
+ # Starting column number (starting from 1).
+ var column_start: Int
+
+ # Stopping line number (starting from 1).
+ var line_end: Int
+
+ # Stopping column number (starting from 1).
+ var column_end: Int
+
+ redef fun to_s do return "{line_start},{column_start}--{line_end},{column_end}"
+end
+
# A block of markdown lines.
# A `MDBlock` can contains lines and/or sub-blocks.
class MDBlock
+
+ # Position of `self` in the input.
+ var location: MDLocation
+
# Kind of block.
# See `Block`.
var kind: Block = new BlockNone(self) is writable
# Split `self` creating a new sub-block having `line` has `last_line`.
fun split(line: MDLine): MDBlock do
- var block = new MDBlock
+ # location for new block
+ var new_loc = new MDLocation(
+ first_line.location.line_start,
+ first_line.location.column_start,
+ line.location.line_end,
+ line.location.column_end)
+ # create block
+ var block = new MDBlock(new_loc)
block.first_line = first_line
block.last_line = line
first_line = line.next
last_line = null
else
first_line.prev = null
+ # update current block loc
+ location.line_start = first_line.location.line_start
+ location.column_start = first_line.location.column_start
end
if first_block == null then
first_block = block
# A markdown line.
class MDLine
+ # Location of `self` in the original input.
+ var location: MDLocation
+
# Text contained in this line.
var value: String is writable
# Some tokens have a specific markup behaviour that is handled here.
abstract class Token
- # Position of `self` in markdown input.
+ # Location of `self` in the original input.
+ var location: MDLocation
+
+ # Position of `self` in input independant from lines.
var pos: Int
# Character found at `pos` in the markdown input.
return null
end
+ # Init a `MDLocation` instance at `pos` in `self`.
+ private fun pos_to_loc(pos: Int): MDLocation do
+ assert pos <= length
+ var line = 1
+ var col = 0
+ var i = 0
+ while i <= pos do
+ col += 1
+ var c = self[i]
+ if c == '\n' then
+ line +=1
+ col = 0
+ end
+ i +=1
+ end
+ return new MDLocation(line, col, line, col)
+ end
+
# Is `self` an unsafe HTML element?
private fun is_html_unsafe: Bool do return html_unsafe_tags.has(self.write_to_string)
class TestBlock
super TestSuite
+ # A dummy location for testing purposes.
+ var loc = new MDLocation(0, 0, 0, 0)
+
fun test_has_blocks do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
assert not subject.has_blocks
- subject.first_block = new MDBlock
+ subject.first_block = new MDBlock(loc)
assert subject.has_blocks
end
fun test_count_blocks do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
assert subject.count_blocks == 0
- subject.first_block = new MDBlock
+ subject.first_block = new MDBlock(loc)
assert subject.count_blocks == 1
- subject.first_block.next = new MDBlock
+ subject.first_block.next = new MDBlock(loc)
assert subject.count_blocks == 2
end
fun test_has_lines do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
assert not subject.has_lines
- subject.first_line = new MDLine("")
+ subject.first_line = new MDLine(loc, "")
assert subject.has_lines
end
fun test_count_lines do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
assert subject.count_lines == 0
- subject.first_line = new MDLine("")
+ subject.first_line = new MDLine(loc, "")
assert subject.count_lines == 1
- subject.first_line.next = new MDLine("")
+ subject.first_line.next = new MDLine(loc, "")
assert subject.count_lines == 2
end
fun test_split do
- var line1 = new MDLine("line1")
- var line2 = new MDLine("line2")
- var line3 = new MDLine("line3")
- var subject = new MDBlock
+ var line1 = new MDLine(loc, "line1")
+ var line2 = new MDLine(loc, "line2")
+ var line3 = new MDLine(loc, "line3")
+ var subject = new MDBlock(loc)
subject.add_line line1
subject.add_line line2
subject.add_line line3
end
fun test_add_line do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
assert subject.count_lines == 0
- subject.add_line new MDLine("")
+ subject.add_line new MDLine(loc, "")
assert subject.count_lines == 1
- subject.add_line new MDLine("")
+ subject.add_line new MDLine(loc, "")
assert subject.count_lines == 2
end
fun test_remove_line do
- var line1 = new MDLine("line1")
- var line2 = new MDLine("line2")
- var line3 = new MDLine("line3")
- var subject = new MDBlock
+ var line1 = new MDLine(loc, "line1")
+ var line2 = new MDLine(loc, "line2")
+ var line3 = new MDLine(loc, "line3")
+ var subject = new MDBlock(loc)
subject.add_line line1
subject.add_line line2
subject.add_line line3
end
fun test_transform_headline1 do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
var kind = new BlockHeadline(subject)
- subject.add_line new MDLine(" # Title 1 ")
+ subject.add_line new MDLine(loc, " # Title 1 ")
kind.transform_headline(subject)
assert kind.depth == 1
assert subject.first_line.value == "Title 1"
end
fun test_transform_headline2 do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
var kind = new BlockHeadline(subject)
- subject.add_line new MDLine(" #####Title 5 ")
+ subject.add_line new MDLine(loc, " #####Title 5 ")
kind.transform_headline(subject)
assert kind.depth == 5
assert subject.first_line.value == "Title 5"
end
fun test_remove_quote_prefix do
- var subject = new MDBlock
+ var subject = new MDBlock(loc)
var kind = new BlockQuote(subject)
- subject.add_line new MDLine(" > line 1")
- subject.add_line new MDLine(" > line 2")
- subject.add_line new MDLine(" > line 3")
+ subject.add_line new MDLine(loc, " > line 1")
+ subject.add_line new MDLine(loc, " > line 2")
+ subject.add_line new MDLine(loc, " > line 3")
kind.remove_block_quote_prefix(subject)
assert subject.first_line.value == "line 1"
assert subject.first_line.next.value == "line 2"
end
fun test_remove_leading_empty_lines_1 do
- var block = new MDBlock
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine(" text")
- block.add_line new MDLine("")
+ var block = new MDBlock(loc)
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, " text")
+ block.add_line new MDLine(loc, "")
assert block.remove_leading_empty_lines
assert block.first_line.value == " text"
end
fun test_remove_leading_empty_lines_2 do
- var block = new MDBlock
- block.add_line new MDLine(" text")
+ var block = new MDBlock(loc)
+ block.add_line new MDLine(loc, " text")
block.remove_leading_empty_lines
assert block.first_line.value == " text"
end
fun test_remove_trailing_empty_lines_1 do
- var block = new MDBlock
- block.add_line new MDLine("")
- block.add_line new MDLine("text")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
+ var block = new MDBlock(loc)
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "text")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
assert block.remove_trailing_empty_lines
assert block.last_line.value == "text"
end
fun test_remove_trailing_empty_lines_2 do
- var block = new MDBlock
- block.add_line new MDLine("text ")
+ var block = new MDBlock(loc)
+ block.add_line new MDLine(loc, "text ")
assert not block.remove_trailing_empty_lines
assert block.last_line.value == "text "
end
fun test_remove_surrounding_empty_lines do
- var block = new MDBlock
- block.add_line new MDLine("")
- block.add_line new MDLine("text")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
- block.add_line new MDLine("")
+ var block = new MDBlock(loc)
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "text")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
+ block.add_line new MDLine(loc, "")
assert block.remove_surrounding_empty_lines
assert block.first_line.value == "text"
assert block.last_line.value == "text"
class TestLine
super TestSuite
+ # A dummy location for testing purposes.
+ var loc = new MDLocation(0, 0, 0, 0)
+
var subject: MDLine
fun test_is_empty do
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert subject.is_empty
- subject = new MDLine(" ")
+ subject = new MDLine(loc, " ")
assert subject.is_empty
- subject = new MDLine("test")
+ subject = new MDLine(loc, "test")
assert not subject.is_empty
- subject = new MDLine(" test")
+ subject = new MDLine(loc, " test")
assert not subject.is_empty
end
fun test_leading do
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert subject.leading == 0
- subject = new MDLine(" ")
+ subject = new MDLine(loc, " ")
assert subject.leading == 4
- subject = new MDLine("test")
+ subject = new MDLine(loc, "test")
assert subject.leading == 0
- subject = new MDLine(" test")
+ subject = new MDLine(loc, " test")
assert subject.leading == 4
end
fun test_trailing do
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert subject.trailing == 0
- subject = new MDLine(" ")
+ subject = new MDLine(loc, " ")
assert subject.trailing == 0
- subject = new MDLine("test ")
+ subject = new MDLine(loc, "test ")
assert subject.trailing == 3
- subject = new MDLine(" test ")
+ subject = new MDLine(loc, " test ")
assert subject.trailing == 1
end
fun test_line_type do
var v = new MarkdownProcessor
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert v.line_kind(subject) isa LineEmpty
- subject = new MDLine(" ")
+ subject = new MDLine(loc, " ")
assert v.line_kind(subject) isa LineEmpty
- subject = new MDLine("text ")
+ subject = new MDLine(loc, "text ")
assert v.line_kind(subject) isa LineOther
- subject = new MDLine(" # Title")
+ subject = new MDLine(loc, " # Title")
assert v.line_kind(subject) isa LineHeadline
- subject = new MDLine(" ### Title")
+ subject = new MDLine(loc, " ### Title")
assert v.line_kind(subject) isa LineHeadline
- subject = new MDLine(" code")
+ subject = new MDLine(loc, " code")
assert v.line_kind(subject) isa LineCode
- subject = new MDLine(" Title ")
- subject.next = new MDLine("== ")
+ subject = new MDLine(loc, " Title ")
+ subject.next = new MDLine(loc, "== ")
assert v.line_kind(subject) isa LineHeadline1
- subject = new MDLine(" Title ")
- subject.next = new MDLine("-- ")
+ subject = new MDLine(loc, " Title ")
+ subject.next = new MDLine(loc, "-- ")
assert v.line_kind(subject) isa LineHeadline2
- subject = new MDLine(" * * * ")
+ subject = new MDLine(loc, " * * * ")
assert v.line_kind(subject) isa LineHR
- subject = new MDLine(" *** ")
+ subject = new MDLine(loc, " *** ")
assert v.line_kind(subject) isa LineHR
- subject = new MDLine("- -- ")
+ subject = new MDLine(loc, "- -- ")
assert v.line_kind(subject) isa LineHR
- subject = new MDLine("--------- ")
+ subject = new MDLine(loc, "--------- ")
assert v.line_kind(subject) isa LineHR
- subject = new MDLine(" >")
+ subject = new MDLine(loc, " >")
assert v.line_kind(subject) isa LineBlockquote
- subject = new MDLine("<p></p>")
+ subject = new MDLine(loc, "<p></p>")
assert v.line_kind(subject) isa LineXML
- subject = new MDLine("<p>")
+ subject = new MDLine(loc, "<p>")
assert v.line_kind(subject) isa LineOther
- subject = new MDLine(" * foo")
+ subject = new MDLine(loc, " * foo")
assert v.line_kind(subject) isa LineUList
- subject = new MDLine("- foo")
+ subject = new MDLine(loc, "- foo")
assert v.line_kind(subject) isa LineUList
- subject = new MDLine("+ foo")
+ subject = new MDLine(loc, "+ foo")
assert v.line_kind(subject) isa LineUList
- subject = new MDLine("1. foo")
+ subject = new MDLine(loc, "1. foo")
assert v.line_kind(subject) isa LineOList
- subject = new MDLine(" 11111. foo")
+ subject = new MDLine(loc, " 11111. foo")
assert v.line_kind(subject) isa LineOList
end
fun test_line_type_ext do
var v = new MarkdownProcessor
- subject = new MDLine(" ~~~")
+ subject = new MDLine(loc, " ~~~")
assert v.line_kind(subject) isa LineFence
- subject = new MDLine(" ```")
+ subject = new MDLine(loc, " ```")
assert v.line_kind(subject) isa LineFence
end
fun test_count_chars do
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert subject.count_chars('*') == 0
- subject = new MDLine("* ")
+ subject = new MDLine(loc, "* ")
assert subject.count_chars('*') == 1
- subject = new MDLine(" * text")
+ subject = new MDLine(loc, " * text")
assert subject.count_chars('*') == 0
- subject = new MDLine(" * * *")
+ subject = new MDLine(loc, " * * *")
assert subject.count_chars('*') == 3
- subject = new MDLine("text ** ")
+ subject = new MDLine(loc, "text ** ")
assert subject.count_chars('*') == 0
end
fun test_count_chars_start do
- subject = new MDLine("")
+ subject = new MDLine(loc, "")
assert subject.count_chars_start('*') == 0
- subject = new MDLine("* ")
+ subject = new MDLine(loc, "* ")
assert subject.count_chars_start('*') == 1
- subject = new MDLine(" * text")
+ subject = new MDLine(loc, " * text")
assert subject.count_chars_start('*') == 1
- subject = new MDLine(" * * * text")
+ subject = new MDLine(loc, " * * * text")
assert subject.count_chars_start('*') == 3
- subject = new MDLine("text ** ")
+ subject = new MDLine(loc, "text ** ")
assert subject.count_chars_start('*') == 0
end
end
assert res == exp
end
end
+
+class TestTokenLocation
+ super TestSuite
+
+ fun test_token_location1 do
+ var string = "**Hello** `World`"
+ var stack = [
+ "TokenStrongStar at 1,1--1,1",
+ "TokenStrongStar at 1,8--1,8",
+ "TokenCodeSingle at 1,11--1,11",
+ "TokenCodeSingle at 1,17--1,17"]
+ (new TestTokenProcessor(stack)).process(string)
+ end
+
+ fun test_token_location2 do
+ var string = "**Hello**\n`World`\n*Bonjour*\n[le monde]()"
+ var stack = [
+ "TokenStrongStar at 1,1--1,1",
+ "TokenStrongStar at 1,8--1,8",
+ "TokenCodeSingle at 2,1--2,1",
+ "TokenCodeSingle at 2,7--2,7",
+ "TokenEmStar at 3,1--3,1",
+ "TokenEmStar at 3,9--3,9",
+ "TokenLink at 4,1--4,1"]
+ (new TestTokenProcessor(stack)).process(string)
+ end
+
+ fun test_token_location3 do
+ var string = """**Hello**
+ `World`
+ *Bonjour*
+ [le monde]()"""
+ var stack = [
+ "TokenStrongStar at 1,1--1,1",
+ "TokenStrongStar at 1,8--1,8",
+ "TokenCodeSingle at 2,1--2,1",
+ "TokenCodeSingle at 2,7--2,7",
+ "TokenEmStar at 3,1--3,1",
+ "TokenEmStar at 3,9--3,9",
+ "TokenLink at 4,1--4,1"]
+ (new TestTokenProcessor(stack)).process(string)
+ end
+end
+
+class TestTokenProcessor
+ super MarkdownProcessor
+
+ var test_stack: Array[String]
+
+ redef fun token_at(input, pos) do
+ var token = super
+ if token isa TokenNone then return token
+ var res = "{token.class_name} at {token.location}"
+ print res
+ var exp = test_stack.shift
+ assert exp == res
+ return token
+ end
+end
+
+class TestBlockLocation
+ super TestSuite
+
+ var proc = new MarkdownProcessor
+
+ fun test_block_location1 do
+ var stack = [
+ "BlockHeadline: 1,1--1,8",
+ "BlockListItem: 2,1--2,6",
+ "BlockListItem: 3,1--3,5"
+ ]
+ var string =
+ "# Title\n* li1\n* li2"
+ proc.emitter.decorator = new TestBlockDecorator(stack)
+ proc.process(string)
+ end
+
+ fun test_block_location2 do
+ var stack = [
+ "BlockHeadline: 1,1--1,11",
+ "BlockFence: 3,1--5,4",
+ "BlockListItem: 7,1--7,7",
+ "BlockListItem: 8,1--8,6"]
+ var string ="""#### Title
+
+~~~fence
+some code
+~~~
+
+1. li1
+1. li2"""
+ proc.emitter.decorator = new TestBlockDecorator(stack)
+ proc.process(string)
+ end
+end
+
+class TestBlockDecorator
+ super HTMLDecorator
+
+ var stack: Array[String]
+
+ redef fun add_headline(v, block) do
+ super
+ check_res(block)
+ end
+
+ redef fun add_listitem(v, block) do
+ super
+ check_res(block)
+ end
+
+ redef fun add_blockquote(v, block) do
+ super
+ check_res(block)
+ end
+
+ redef fun add_code(v, block) do
+ super
+ check_res(block)
+ end
+
+ fun check_res(block: Block) do
+ var res = "{block.class_name}: {block.block.location}"
+ var exp = stack.shift
+ assert res == exp
+ end
+end
if not token isa TokenLink then return token
if pos + 1 < text.length then
var c = text[pos + 1]
- if c == '[' then return new TokenWikiLink(pos, c)
+ if c == '[' then return new TokenWikiLink(token.location, pos, c)
end
return token
end
int di;
char *in_text;
- in_text = String_to_cstring(recv);
+ in_text = String_to_cstring(self);
md5_init(&state);
md5_append(&state, (const md5_byte_t *)in_text, strlen(in_text));
}
/* Used by Android to set buffer geometry */
- Opengles1Display_midway_init(recv, format);
+ Opengles1Display_midway_init(self, format);
surface = eglCreateWindowSurface(display, config, mnit_window, NULL);
context = eglCreateContext(display, config, NULL, NULL);
extern class Opengles1Image in "C" `{struct mnit_opengles_Texture *`}
super Image
- redef fun destroy is extern `{ free( recv ); `}
+ redef fun destroy is extern `{ free( self ); `}
- redef fun width: Int is extern `{ return recv->width; `}
- redef fun height: Int is extern `{ return recv->height; `}
+ redef fun width: Int is extern `{ return self->width; `}
+ redef fun height: Int is extern `{ return self->height; `}
- fun center_x: Int `{ return recv->center_x; `}
- fun center_y: Int `{ return recv->center_y; `}
+ fun center_x: Int `{ return self->center_x; `}
+ fun center_y: Int `{ return self->center_y; `}
redef fun scale=( v: Float ) is extern `{
- recv->scale = v;
- recv->center_x = v*recv->width/2;
- recv->center_y = v*recv->height/2;
+ self->scale = v;
+ self->center_x = v*self->width/2;
+ self->center_y = v*self->height/2;
`}
- redef fun scale: Float is extern `{ return recv->scale; `}
+ redef fun scale: Float is extern `{ return self->scale; `}
- redef fun blended=( v: Bool ) is extern `{ recv->blended = v; `}
- redef fun blended: Bool is extern `{ return recv->blended; `}
+ redef fun blended=( v: Bool ) is extern `{ self->blended = v; `}
+ redef fun blended: Bool is extern `{ return self->blended; `}
# inherits scale and blend from source
redef fun subimage( x, y, w, h: Int ): Image is extern import Opengles1Image.as( Image ) `{
struct mnit_opengles_Texture* image =
malloc( sizeof( struct mnit_opengles_Texture ) );
- image->texture = recv->texture;
+ image->texture = self->texture;
image->width = w;
image->height = h;
- image->center_x = recv->scale*w/2;
- image->center_y = recv->scale*h/2;
- image->scale = recv->scale;
- image->blended = recv->blended;
-
- float r_dx = recv->src_xi - recv->src_xo;
- float r_dy = recv->src_yi - recv->src_yo;
- image->src_xo = recv->src_xo + ((float)x)/recv->width*r_dx;
- image->src_yo = recv->src_yo + ((float)y)/recv->height*r_dy;
- image->src_xi = recv->src_xo + ((float)x+w)/recv->width*r_dx;
- image->src_yi = recv->src_yo + ((float)y+h)/recv->height*r_dy;
+ image->center_x = self->scale*w/2;
+ image->center_y = self->scale*h/2;
+ image->scale = self->scale;
+ image->blended = self->blended;
+
+ float r_dx = self->src_xi - self->src_xo;
+ float r_dy = self->src_yi - self->src_yo;
+ image->src_xo = self->src_xo + ((float)x)/self->width*r_dx;
+ image->src_yo = self->src_yo + ((float)y)/self->height*r_dy;
+ image->src_xi = self->src_xo + ((float)x+w)/self->width*r_dx;
+ image->src_yi = self->src_yo + ((float)y+h)/self->height*r_dy;
return Opengles1Image_as_Image( image );
`}
void mnit_android_png_read_data(png_structp png_ptr,
png_bytep data, png_size_t length)
{
- struct AAsset *recv = png_get_io_ptr(png_ptr);
- int read = AAsset_read(recv, data, length);
+ struct AAsset *self = png_get_io_ptr(png_ptr);
+ int read = AAsset_read(self, data, length);
}
void mnit_android_png_error_fn(png_structp png_ptr,
png_const_charp error_msg)
fun read(count: Int): nullable String is extern import String.as nullable, NativeString.to_s `{
char *buffer = malloc(sizeof(char) * (count+1));
- int read = AAsset_read(recv, buffer, count);
+ int read = AAsset_read(self, buffer, count);
if (read != count)
return null_String();
else
`}
fun length: Int is extern `{
- return AAsset_getLength(recv);
+ return AAsset_getLength(self);
`}
fun to_fd: Int is extern `{
off_t start;
off_t length;
- int fd = AAsset_openFileDescriptor(recv, &start, &length);
+ int fd = AAsset_openFileDescriptor(self, &start, &length);
return fd;
`}
fun close is extern `{
- AAsset_close(recv);
+ AAsset_close(self);
`}
end
end
protected fun load_asset_from_apk(path: String): nullable AndroidAsset is extern import String.to_cstring, AndroidAsset.as nullable, native_app_glue `{
- struct android_app *native_app_glue = App_native_app_glue(recv);
+ struct android_app *native_app_glue = App_native_app_glue(self);
struct AAsset* a = AAssetManager_open(native_app_glue->activity->assetManager, String_to_cstring(path), AASSET_MODE_BUFFER);
if (a == NULL)
{
redef class Opengles1Image
# Read a png from a zipped stream
new from_android_asset(asset: AndroidAsset) import Int.next_pow `{
- struct mnit_opengles_Texture *recv = NULL;
+ struct mnit_opengles_Texture *self = NULL;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
for (i = 0; i < height; i++)
memcpy(pixels + (row_bytes_pow2*i), row_pointers[i], row_bytes);
- recv = mnit_opengles_load_image((const uint_least32_t *)pixels,
+ self = mnit_opengles_load_image((const uint_least32_t *)pixels,
width, height, width_pow2, height_pow2, has_alpha);
// Calculate the size of the client-side memory allocated and freed
}
close_stream:
- return recv;
+ return self;
`}
end
redef class Opengles1Display
redef fun midway_init(format) import app_native_window `{
- mnit_window = Opengles1Display_app_native_window(recv);
+ mnit_window = Opengles1Display_app_native_window(self);
if (ANativeWindow_setBuffersGeometry(mnit_window, 0, 0, (EGLint)format) != 0) {
LOGW("Unable to ANativeWindow_setBuffersGeometry");
}
bson_t *bson;
bson = bson_new_from_json(data, -1, &error);
if(!bson) {
- NativeBSON_set_mongoc_error(recv, &error);
+ NativeBSON_set_mongoc_error(bson, &error);
return NULL;
}
return bson;
# The `bson_as_json()` function shall encode bson as a JSON encoded UTF-8 string.
# The caller is responsible for freeing the resulting UTF-8 encoded string
# by calling `bson_free()` with the result.
- fun to_native_string: NativeString `{ return bson_as_json(recv, NULL); `}
+ fun to_native_string: NativeString `{ return bson_as_json(self, NULL); `}
# Wrapper for `bson_destroy()`.
#
# unless otherwise specified.
#
# This instance should not be used beyond this point!
- fun destroy `{ bson_destroy(recv); `}
+ fun destroy `{ bson_destroy(self); `}
# Utility method to set `Sys.last_mongoc_error`.
fun set_mongoc_error(err: BSONError) do sys.last_mongoc_error = err
#
# The `error.domain` field contains the logical domain within a library that
# created the error.
- fun domain: Int `{ return recv->domain; `}
+ fun domain: Int `{ return self->domain; `}
# Wrapper for `error.code`.
#
# The `error.code` field contains the domain specific error code.
- fun code: Int `{ return recv->code; `}
+ fun code: Int `{ return self->code; `}
# Wrapper for `error.message`.
#
# The `error.message` field contains a human printable error message.
- fun message: NativeString `{ return recv->message; `}
+ fun message: NativeString `{ return self->message; `}
end
redef class Sys
# Frees `self`.
#
# This instance should not be used beyond this point!
- fun destroy `{ free(recv); `}
+ fun destroy `{ free(self); `}
end
# Wrapper for `mongoc_client_t`.
fun server_status: nullable NativeBSON import set_mongoc_error, NativeBSON.as nullable `{
bson_error_t error;
bson_t *reply = bson_new();
- if(!mongoc_client_get_server_status(recv, NULL, reply, &error)){
- NativeMongoClient_set_mongoc_error(recv, &error);
+ if(!mongoc_client_get_server_status(self, NULL, reply, &error)){
+ NativeMongoClient_set_mongoc_error(self, &error);
return null_NativeBSON();
}
return NativeBSON_as_nullable(reply);
import set_mongoc_error, NativeCStringArray, NativeCStringArray.as nullable `{
bson_error_t error;
char **strv;
- if(strv = mongoc_client_get_database_names(recv, &error)) {
+ if(strv = mongoc_client_get_database_names(self, &error)) {
return NativeCStringArray_as_nullable(strv);
}
- NativeMongoClient_set_mongoc_error(recv, &error);
+ NativeMongoClient_set_mongoc_error(self, &error);
return null_NativeCStringArray();
`}
#
# This instance should not be used beyond this point!
fun destroy `{
- mongoc_client_destroy(recv);
+ mongoc_client_destroy(self);
mongoc_cleanup();
`}
import set_mongoc_error, NativeCStringArray, NativeCStringArray.as nullable `{
bson_error_t error;
char **strv;
- if(strv = mongoc_database_get_collection_names(recv, &error)) {
+ if(strv = mongoc_database_get_collection_names(self, &error)) {
return NativeCStringArray_as_nullable(strv);
}
- NativeMongoDb_set_mongoc_error(recv, &error);
+ NativeMongoDb_set_mongoc_error(self, &error);
return null_NativeCStringArray();
`}
# Allocates a new `mongoc_collection_t` structure for the collection named
# `name` in database.
fun collection(name: NativeString): NativeMongoCollection `{
- return mongoc_database_get_collection(recv, name);
+ return mongoc_database_get_collection(self, name);
`}
# Wrapper for `mongoc_database_has_collection()`.
# within database.
fun has_collection(name: NativeString): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_database_has_collection(recv, name, &error)) {
- NativeMongoDb_set_mongoc_error(recv, &error);
+ if(!mongoc_database_has_collection(self, name, &error)) {
+ NativeMongoDb_set_mongoc_error(self, &error);
return false;
}
return true;
# This function attempts to drop a database on the MongoDB server.
fun drop: Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_database_drop(recv, &error)) {
- NativeMongoDb_set_mongoc_error(recv, &error);
+ if(!mongoc_database_drop(self, &error)) {
+ NativeMongoDb_set_mongoc_error(self, &error);
return false;
}
return true;
# Wrapper for `mongoc_database_destroy()`.
#
# This instance should not be used beyond this point!
- fun destroy `{ mongoc_database_destroy(recv); `}
+ fun destroy `{ mongoc_database_destroy(self); `}
# Utility method to set `Sys.last_mongoc_error`.
fun set_mongoc_error(err: BSONError) do sys.last_mongoc_error = err
# You can retrieve a generated `_id` from `mongoc_collection_get_last_error()`.
fun insert(doc: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_insert(recv, MONGOC_INSERT_NONE, doc, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_insert(self, MONGOC_INSERT_NONE, doc, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# Otherwise it will be inserted.
fun save(document: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_save(recv, document, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_save(self, document, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# The bson selector is not validated, simply passed along as appropriate to the server.
fun remove(selector: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_remove(recv, MONGOC_REMOVE_SINGLE_REMOVE, selector, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_remove(self, MONGOC_REMOVE_SINGLE_REMOVE, selector, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# This function shall remove documents in the collection that match `selector`.
fun remove_all(selector: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_remove(recv, MONGOC_REMOVE_NONE, selector, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_remove(self, MONGOC_REMOVE_NONE, selector, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# matches `selector`.
fun update(selector, update: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_update(recv, MONGOC_UPDATE_NONE, selector, update, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_update(self, MONGOC_UPDATE_NONE, selector, update, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# This function shall update documents in the collection that match `selector`.
fun update_all(selector, update: NativeBSON): Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_update(recv, MONGOC_UPDATE_MULTI_UPDATE, selector, update, NULL, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_update(self, MONGOC_UPDATE_MULTI_UPDATE, selector, update, NULL, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# This function shall execute a count `query` on the underlying collection.
fun count(query: NativeBSON): Int import set_mongoc_error `{
bson_error_t error;
- int64_t count = mongoc_collection_count(recv, MONGOC_QUERY_NONE, query, 0, 0, NULL, &error);
+ int64_t count = mongoc_collection_count(self, MONGOC_QUERY_NONE, query, 0, 0, NULL, &error);
if(count < 0) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ NativeMongoCollection_set_mongoc_error(self, &error);
return -1;
}
return count;
NativeMongoCursor.as nullable, set_mongoc_error `{
bson_error_t error;
mongoc_cursor_t *cursor;
- cursor = mongoc_collection_find(recv, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
+ cursor = mongoc_collection_find(self, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
if (mongoc_cursor_error(cursor, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ NativeMongoCollection_set_mongoc_error(self, &error);
return null_NativeMongoCursor();
}
fun stats: nullable NativeBSON import set_mongoc_error, NativeBSON.as nullable `{
bson_error_t error;
bson_t *reply = bson_new();
- if(!mongoc_collection_stats(recv, NULL, reply, &error)){
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_stats(self, NULL, reply, &error)){
+ NativeMongoCollection_set_mongoc_error(self, &error);
return null_NativeBSON();
}
return NativeBSON_as_nullable(reply);
# including all indexes associated with the collection.
fun drop: Bool import set_mongoc_error `{
bson_error_t error;
- if(!mongoc_collection_drop(recv, &error)) {
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_drop(self, &error)) {
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# Additional operations will occur on renamed collection.
fun rename(new_database, new_name: NativeString): Bool `{
bson_error_t error;
- if(!mongoc_collection_rename(recv, new_database, new_name, false, &error)){
- NativeMongoCollection_set_mongoc_error(recv, &error);
+ if(!mongoc_collection_rename(self, new_database, new_name, false, &error)){
+ NativeMongoCollection_set_mongoc_error(self, &error);
return false;
}
return true;
# Wrapper for `mongoc_collection_destroy()`.
#
# This instance should not be used beyond this point!
- fun destroy `{ mongoc_collection_destroy(recv); `}
+ fun destroy `{ mongoc_collection_destroy(self); `}
# Utility method to set `Sys.last_mongoc_error`.
fun set_mongoc_error(err: BSONError) do sys.last_mongoc_error = err
# Wrapper for `mongoc_cursor_current()`.
#
# Fetches the cursors current document or NULL if there has been an error.
- fun current: NativeBSON `{ return (bson_t*) mongoc_cursor_current(recv); `}
+ fun current: NativeBSON `{ return (bson_t*) mongoc_cursor_current(self); `}
# Wrapper for `mongoc_cursor_next()`.
#
# This function is a blocking function.
fun next: Bool `{
const bson_t *doc;
- return mongoc_cursor_next(recv, &doc);
+ return mongoc_cursor_next(self, &doc);
`}
# Wrapper for `mongoc_cursor_more()`.
#
# This function shall indicate if there is more data to be read from the cursor.
- fun more: Bool `{ return mongoc_cursor_more(recv); `}
+ fun more: Bool `{ return mongoc_cursor_more(self); `}
# Wrapper for `mongoc_cursor_destroy()`.
#
# This instance should not be used beyond this point!
- fun destroy `{ mongoc_cursor_destroy(recv); `}
+ fun destroy `{ mongoc_cursor_destroy(self); `}
end
# Highly specific, but useful, collections-related classes.
module more_collections
+import serialization
+
# Simple way to store an `HashMap[K, Array[V]]`
#
# Unlike standard HashMap, MultiHashMap provides a new
# assert m["four"] == ['i', 'i', 'i', 'i']
# assert m["zzz"] == new Array[Char]
class MultiHashMap[K, V]
+ auto_serializable
super HashMap[K, Array[V]]
# Add `v` to the array associated with `k`.
# assert hm2[2, "not-two"] == null
# ~~~~
class HashMap2[K1, K2, V]
+ auto_serializable
+
private var level1 = new HashMap[K1, HashMap[K2, V]]
# Return the value associated to the keys `k1` and `k2`.
# assert hm3[2, "not-two", 22] == null
# ~~~~
class HashMap3[K1, K2, K3, V]
+ auto_serializable
+
private var level1 = new HashMap[K1, HashMap2[K2, K3, V]]
# Return the value associated to the keys `k1`, `k2`, and `k3`.
# assert dma.default == [65]
# ~~~~
class DefaultMap[K, V]
+ auto_serializable
super HashMap[K, V]
# The default value.
redef fun provide_default_value(key) do return default
end
+
+# An unrolled linked list
+#
+# A sequence implemented as a linked list of arrays.
+#
+# This data structure is similar to the `List` but it can benefit from
+# better cache performance, lower data overhead for the nodes metadata and
+# it spares the GC to allocate many small nodes.
+class UnrolledList[E]
+ super Sequence[E]
+
+ # Desired capacity for each nodes
+ #
+ # By default at `32`, it can be increased for very large lists.
+ #
+ # It can be modified anytime, but newly created nodes may still be assigned
+ # the same capacity of old nodes when created by `insert`.
+ var nodes_length = 32 is writable
+
+ private var head_node: UnrolledNode[E] = new UnrolledNode[E](nodes_length)
+
+ private var tail_node: UnrolledNode[E] = head_node
+
+ redef var length = 0
+
+ redef fun clear
+ do
+ head_node = new UnrolledNode[E](nodes_length)
+ tail_node = head_node
+ length = 0
+ end
+
+ # Out parameter of `node_at`
+ private var index_within_node = 0
+
+ private fun node_at(index: Int): UnrolledNode[E]
+ do
+ assert index >= 0 and index < length
+
+ var node = head_node
+ while index >= node.length do
+ index -= node.length
+ node = node.next.as(not null)
+ end
+
+ index_within_node = index
+ return node
+ end
+
+ private fun insert_node(node: UnrolledNode[E], prev, next: nullable UnrolledNode[E])
+ do
+ if prev != null then
+ prev.next = node
+ else head_node = node
+
+ if next != null then
+ next.prev = node
+ else tail_node = node
+
+ node.next = next
+ node.prev = prev
+ end
+
+ redef fun [](index)
+ do
+ var node = node_at(index)
+ index = index_within_node + node.head_index
+ return node.items[index]
+ end
+
+ redef fun []=(index, value)
+ do
+ var node = node_at(index)
+ index = index_within_node + node.head_index
+ node.items[index] = value
+ end
+
+ redef fun push(item)
+ do
+ var node = tail_node
+ if not node.full then
+ if node.tail_index < node.capacity then
+ # There's room at the tail
+ node.tail_index += 1
+ else
+ # Move everything over by `d`
+ assert node.head_index > 0
+ var d = node.head_index / 2 + 1
+ node.move_head(node.length, d)
+ for i in d.times do node.items[node.tail_index - i] = null
+ node.head_index -= d
+ node.tail_index += -d+1
+ end
+ node.items[node.tail_index-1] = item
+ else
+ # New node!
+ node = new UnrolledNode[E](nodes_length)
+ insert_node(node, tail_node, null)
+ node.tail_index = 1
+ node.items[0] = item
+ end
+ length += 1
+ end
+
+ redef fun unshift(item)
+ do
+ var node = head_node
+ if not node.full then
+ if node.head_index > 0 then
+ # There's room at the head
+ node.head_index -= 1
+ else
+ # Move everything over by `d`
+ assert node.tail_index < node.capacity
+ var d = (node.capacity-node.tail_index) / 2 + 1
+ node.move_tail(0, d)
+ for i in d.times do node.items[node.head_index+i] = null
+ node.head_index += d-1
+ node.tail_index += d
+ end
+ node.items[node.head_index] = item
+ else
+ # New node!
+ node = new UnrolledNode[E](nodes_length)
+ insert_node(node, null, head_node)
+ node.head_index = node.capacity-1
+ node.tail_index = node.capacity
+ node.items[node.capacity-1] = item
+ end
+ length += 1
+ end
+
+ redef fun pop
+ do
+ assert not_empty
+
+ var node = tail_node
+ while node.length == 0 do
+ # Delete empty node
+ var nullable_node = node.prev
+ assert is_not_empty: nullable_node != null
+ node = nullable_node
+ node.next = null
+ self.tail_node = node
+ end
+
+ var item = node.items[node.tail_index-1]
+ node.tail_index -= 1
+ length -= 1
+ return item
+ end
+
+ redef fun shift
+ do
+ assert not_empty
+
+ var node = head_node
+ while node.length == 0 do
+ # Delete empty node
+ var nullable_node = node.next
+ assert is_not_empty: nullable_node != null
+ node = nullable_node
+ node.prev = null
+ self.head_node = node
+ end
+
+ var item = node.items[node.head_index]
+ node.head_index += 1
+ length -= 1
+ return item
+ end
+
+ redef fun insert(item, index)
+ do
+ if index == length then
+ push item
+ return
+ end
+
+ var node = node_at(index)
+ index = index_within_node
+ if node.full then
+ # Move half to a new node
+ var new_node = new UnrolledNode[E](nodes_length.max(node.capacity))
+
+ # Plug in the new node
+ var next_node = node.next
+ insert_node(new_node, node, next_node)
+
+ # Move items at and after `index` to the new node
+ var to_displace = node.length-index
+ var offset = (new_node.capacity-to_displace)/2
+ for i in [0..to_displace[ do
+ new_node.items[offset+i] = node.items[index+i]
+ node.items[index+i] = null
+ end
+ new_node.head_index = offset
+ new_node.tail_index = offset + to_displace
+ node.tail_index -= to_displace
+
+ # Store `item`
+ if index > node.capacity / 2 then
+ new_node.items[offset-1] = item
+ new_node.head_index -= 1
+ else
+ node.items[node.head_index+index] = item
+ node.tail_index += 1
+ end
+ else
+ if node.tail_index < node.capacity then
+ # Move items towards the tail
+ node.move_tail(index, 1)
+ node.tail_index += 1
+ node.items[node.head_index + index] = item
+ else
+ # Move items towards the head
+ node.move_head(index, 1)
+ node.items[node.head_index + index-1] = item
+ node.head_index -= 1
+ end
+ end
+ length += 1
+ end
+
+ redef fun remove_at(index)
+ do
+ var node = node_at(index)
+ index = index_within_node + node.head_index
+
+ # Shift left all the elements after `index`
+ for i in [index+1 .. node.tail_index[ do
+ node.items[i-1] = node.items[i]
+ end
+ node.tail_index -= 1
+ node.items[node.tail_index] = null
+
+ length -= 1
+
+ var next_node = node.next
+ var prev_node = node.prev
+ if node.is_empty and (next_node != null or prev_node != null) then
+ # Empty and non-head or tail node, delete
+ if next_node != null then
+ next_node.prev = node.prev
+ else tail_node = prev_node.as(not null)
+
+ if prev_node != null then
+ prev_node.next = node.next
+ else head_node = next_node.as(not null)
+ end
+ end
+
+ redef fun iterator do return new UnrolledIterator[E](self)
+end
+
+# Node composing an `UnrolledList`
+#
+# Stores the elements in the `items` array. The elements in the `items` array
+# begin at `head_index` and end right before `tail_index`. The data is contiguous,
+# but there can be empty cells at the beginning and the end of the array.
+private class UnrolledNode[E]
+
+ var prev: nullable UnrolledNode[E] = null
+
+ var next: nullable UnrolledNode[E] = null
+
+ # Desired length of `items`
+ var capacity: Int
+
+ # `Array` of items in this node, filled with `null`
+ var items = new Array[nullable E].filled_with(null, capacity) is lazy
+
+ # Index of the first element in `items`
+ var head_index = 0
+
+ # Index after the last element in `items`
+ var tail_index = 0
+
+ fun length: Int do return tail_index - head_index
+
+ fun full: Bool do return length == capacity
+
+ fun is_empty: Bool do return tail_index == head_index
+
+ # Move towards the head all elements before `index` of `displace` cells
+ fun move_tail(index, displace: Int)
+ do
+ for i in [tail_index-1..head_index+index].step(-1) do
+ items[i+displace] = items[i]
+ end
+ end
+
+ # Move towards the tail all elements at and after `index` of `displace` cells
+ fun move_head(index, displace: Int)
+ do
+ for i in [head_index..head_index+index[ do
+ items[i-displace] = items[i]
+ end
+ end
+end
+
+private class UnrolledIterator[E]
+ super IndexedIterator[E]
+
+ var list: UnrolledList[E]
+
+ var node: nullable UnrolledNode[E] = list.head_node is lazy
+
+ # Index of the current `item`
+ redef var index = 0
+
+ # Index within the current `node`
+ var index_in_node: Int = node.head_index is lazy
+
+ redef fun item do return node.items[index_in_node]
+
+ redef fun is_ok do return index < list.length
+
+ redef fun next
+ do
+ index += 1
+ index_in_node += 1
+
+ if index_in_node >= node.tail_index then
+ node = node.next
+ if node != null then index_in_node = node.head_index
+ end
+ end
+end
# Number of processors in this communicator
fun size: Int `{
int size;
- MPI_Comm_size(recv, &size);
+ MPI_Comm_size(self, &size);
return size;
`}
# Rank on this processor in this communicator
fun rank: Rank `{
int rank;
- MPI_Comm_rank(recv, &rank);
+ MPI_Comm_rank(self, &rank);
return rank;
`}
end
new `{ return malloc(sizeof(MPI_Status)); `}
# Source of this communication
- fun source: Rank `{ return recv->MPI_SOURCE; `}
+ fun source: Rank `{ return self->MPI_SOURCE; `}
# Tag of this communication
- fun tag: Tag `{ return recv->MPI_TAG; `}
+ fun tag: Tag `{ return self->MPI_TAG; `}
# Success or error on this communication
- fun error: SuccessOrError `{ return recv->MPI_ERROR; `}
+ fun error: SuccessOrError `{ return self->MPI_ERROR; `}
# Count of the given `data_type` in this communication
fun count(data_type: DataType): Int
`{
int count;
- MPI_Get_count(recv, data_type, &count);
+ MPI_Get_count(self, data_type, &count);
return count;
`}
end
# An MPI return code to report success or errors
extern class SuccessOrError `{ int `}
# Is this a success?
- fun is_success: Bool `{ return recv == MPI_SUCCESS; `}
+ fun is_success: Bool `{ return self == MPI_SUCCESS; `}
# Is this an error?
fun is_error: Bool do return not is_success
fun error_class: ErrorClass
`{
int class;
- MPI_Error_class(recv, &class);
+ MPI_Error_class(self, &class);
return class;
`}
redef fun to_s do return native_to_s.to_s
private fun native_to_s: NativeString `{
char *err = malloc(MPI_MAX_ERROR_STRING);
- MPI_Error_string(recv, err, NULL);
+ MPI_Error_string(self, err, NULL);
return err;
`}
end
redef fun to_s do return native_to_s.to_s
private fun native_to_s: NativeString `{
char *err = malloc(MPI_MAX_ERROR_STRING);
- MPI_Error_string(recv, err, NULL);
+ MPI_Error_string(self, err, NULL);
return err;
`}
end
new any `{ return MPI_ANY_SOURCE; `}
# This Rank as an `Int`
- fun to_i: Int `{ return recv; `}
+ fun to_i: Int `{ return self; `}
redef fun to_s do return to_i.to_s
end
new any `{ return MPI_ANY_TAG; `}
# This tag as an `Int`
- fun to_i: Int `{ return recv; `}
+ fun to_i: Int `{ return self; `}
redef fun to_s do return to_i.to_s
end
redef universal Int
# `self`th MPI rank
- fun rank: Rank `{ return recv; `}
+ fun rank: Rank `{ return self; `}
# Tag identified by `self`
- fun tag: Tag `{ return recv; `}
+ fun tag: Tag `{ return self; `}
# Is this value undefined according to MPI? (may be returned by `Status::count`)
- fun is_undefined: Bool `{ return recv == MPI_UNDEFINED; `}
+ fun is_undefined: Bool `{ return self == MPI_UNDEFINED; `}
end
# Something sendable directly and efficiently over MPI
#
# SEE: `create_node`
# SEE: `register`
- redef fun add(node: NeoNode) is abstract
+ redef fun add(node) is abstract
# Add a new node to the graph and return it.
#
redef fun to_s do return to_json
# Append the JSON representation of the node to the specified buffer.
- redef fun append_json_for(graph: NeoGraph, buffer: Buffer) do
+ redef fun append_json_for(graph, buffer) do
append_json(buffer)
end
end
# Append the JSON representation of the relationship to the specified buffer.
#
# Use the IDs specfied by `graph.nodes`.
- redef fun append_json_for(graph: NeoGraph, buffer: Buffer) do
+ redef fun append_json_for(graph, buffer) do
buffer.append "\{\"type\":"
rel_type.append_json(buffer)
buffer.append ",\"properties\":"
return nodes[id]
end
- redef fun has_id(id: Int): Bool do
+ redef fun has_id(id) do
return id >= 0 and id < nodes.length and nodes[id] isa NeoNode
end
end
# Get this reponse as a string according to HTTP protocol
- redef fun to_s: String
+ redef fun to_s
do
finalize
extern class PepperDictionary `{ struct PP_Var* `}
new `{
- struct PP_Var* recv = malloc( sizeof( struct PP_Var ) );
- *recv = g_varDictionaryInterface->Create();
- return recv;
+ struct PP_Var* self = malloc( sizeof( struct PP_Var ) );
+ *self = g_varDictionaryInterface->Create();
+ return self;
`}
# Get fonction using PepperVars.
# If 'key' is not a String typed PepperVar, or doesn't exist in the Dictionary, an undefined PepperVar is returned.
fun native_get(key: PepperVar): PepperVar `{
struct PP_Var* value = malloc( sizeof ( struct PP_Var ) );
- *value = g_varDictionaryInterface->Get(*recv, *key);
+ *value = g_varDictionaryInterface->Get(*self, *key);
return value;
`}
# Returns a Boolean indicating whether the operation succeeds.
fun native_set(key: PepperVar, value: PepperVar): Bool `{
PP_Bool b;
- b = g_varDictionaryInterface->Set(*recv, *key, *value);
+ b = g_varDictionaryInterface->Set(*self, *key, *value);
return b;
`}
#
# Takes a String typed PepperVar.
fun native_delete(key: PepperVar) `{
- g_varDictionaryInterface->Delete(*recv, *key);
+ g_varDictionaryInterface->Delete(*self, *key);
`}
# Deletes the specified key and its associated value, if the key exists.
# Takes a String typed PepperVar.
fun native_has_key(key: PepperVar): Bool `{
PP_Bool b;
- b = g_varDictionaryInterface->HasKey(*recv, *key);
+ b = g_varDictionaryInterface->HasKey(*self, *key);
return b;
`}
# Returns a PepperArray which contains all the keys of the Dictionary. The elements are string vars.
fun get_keys: PepperArray `{
struct PP_Var* array = malloc( sizeof( struct PP_Var ) );
- *array = g_varDictionaryInterface->GetKeys(*recv);
+ *array = g_varDictionaryInterface->GetKeys(*self);
return array;
`}
fun copy: PepperDictionary `{
struct PP_Var* varDictionary = malloc( sizeof( struct PP_Var ) );
*varDictionary = g_varDictionaryInterface->Create();
- *varDictionary = *recv;
+ *varDictionary = *self;
return varDictionary;
`}
end
extern class PepperArray `{ struct PP_Var* `}
new `{
- struct PP_Var* recv = malloc( sizeof( struct PP_Var ) );
- *recv = g_varArrayInterface->Create();
- return recv;
+ struct PP_Var* self = malloc( sizeof( struct PP_Var ) );
+ *self = g_varArrayInterface->Create();
+ return self;
`}
# Returns the element at the specified position as a PepperVar.
# If 'index' is larger than or equal to the array length, an undefined PepperVar is returned.
fun native_get(index: Int): PepperVar `{
struct PP_Var* value = malloc( sizeof( struct PP_Var ) );
- *value = g_varArrayInterface->Get(*recv, index);
+ *value = g_varArrayInterface->Get(*self, index);
return value;
`}
# Returns an int containing the length of the PepperArray.
fun length: Int `{
- int length = g_varArrayInterface->GetLength(*recv);
+ int length = g_varArrayInterface->GetLength(*self);
return length;
`}
# Returns a Boolean indicating whether the operation succeeds.
fun native_set(index: Int, value: PepperVar): Bool `{
PP_Bool b;
- b = g_varArrayInterface->Set(*recv, index, *value);
+ b = g_varArrayInterface->Set(*self, index, *value);
return b;
`}
# Returns a Boolean indicating whether the operation succeeds.
fun length=(length: Int): Bool `{
PP_Bool b;
- b = g_varArrayInterface->SetLength(*recv, length);
+ b = g_varArrayInterface->SetLength(*self, length);
return b;
`}
end
return null
end
- private fun isa_null: Bool `{ return recv->type == PP_VARTYPE_NULL; `}
- private fun isa_bool: Bool `{ return recv->type == PP_VARTYPE_BOOL; `}
- private fun isa_int: Bool `{ return recv->type == PP_VARTYPE_INT32; `}
- private fun isa_float: Bool `{ return recv->type == PP_VARTYPE_DOUBLE; `}
- private fun isa_string: Bool `{ return recv->type == PP_VARTYPE_STRING; `}
- private fun is_undefined: Bool `{ return recv->type == PP_VARTYPE_UNDEFINED; `}
+ private fun isa_null: Bool `{ return self->type == PP_VARTYPE_NULL; `}
+ private fun isa_bool: Bool `{ return self->type == PP_VARTYPE_BOOL; `}
+ private fun isa_int: Bool `{ return self->type == PP_VARTYPE_INT32; `}
+ private fun isa_float: Bool `{ return self->type == PP_VARTYPE_DOUBLE; `}
+ private fun isa_string: Bool `{ return self->type == PP_VARTYPE_STRING; `}
+ private fun is_undefined: Bool `{ return self->type == PP_VARTYPE_UNDEFINED; `}
- private fun as_bool: Bool `{ return recv->value.as_bool; `}
- private fun as_int: Int `{ return recv->value.as_int; `}
- private fun as_float: Float `{ return recv->value.as_double; `}
+ private fun as_bool: Bool `{ return self->value.as_bool; `}
+ private fun as_int: Int `{ return self->value.as_int; `}
+ private fun as_float: Float `{ return self->value.as_double; `}
private fun as_string: String import NativeString.to_s_with_length `{
uint32_t len;
- char* str = (char*)g_varInterface->VarToUtf8(*recv, &len);
+ char* str = (char*)g_varInterface->VarToUtf8(*self, &len);
return NativeString_to_s_with_length(str, len);
`}
end
# Converts a Int into a PepperVar with Int type.
redef fun to_pepper `{
struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
- *var = PP_MakeInt32(recv);
+ *var = PP_MakeInt32(self);
return var;
`}
end
# Converts a Float into a PepperVar with Float type.
redef fun to_pepper `{
struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
- *var = PP_MakeDouble(recv);
+ *var = PP_MakeDouble(self);
return var;
`}
end
# Converts a Bool into a PepperVar with Bool type.
redef fun to_pepper `{
struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
- *var = PP_MakeBool(recv);
+ *var = PP_MakeBool(self);
return var;
`}
end
# Converts a String into a PepperVar with String type.
redef fun to_pepper: PepperVar import String.to_cstring, String.length `{
- char *str = String_to_cstring(recv);
+ char *str = String_to_cstring(self);
struct PP_Var* var = malloc( sizeof( struct PP_Var ) );
- *var = g_varInterface->VarFromUtf8(str, String_length(recv));
+ *var = g_varInterface->VarFromUtf8(str, String_length(self));
return var;
`}
end
# fill_buffer now checks for a message in the message queue which is filled by user inputs.
redef fun fill_buffer
do
- _buffer.clear
_buffer_pos = 0
- _buffer.append check_message.to_s
+ var nns = check_message
+ var nslen = nns.cstring_length
+ _buffer_length = nslen
+ nns.copy_to(buffer, nslen, 0, 0)
end
end
# Sets everything up to work, need to be called at first.
fun initialize import PnaclApp.handle_message, PnaclApp.handle_dictionary, NativeString.to_s_with_length `{
- app = recv;
+ app = self;
`}
# Posts a message to JS.
redef extern class Passwd
# User information
- fun gecos: String import NativeString.to_s `{ return NativeString_to_s(recv->pw_gecos); `}
+ fun gecos: String import NativeString.to_s `{ return NativeString_to_s(self->pw_gecos); `}
end
redef extern class NativePthread
fun cancel: Bool `{
- return pthread_cancel(*recv);
+ return pthread_cancel(*self);
`}
end
return barrier;
`}
- fun destroy `{ pthread_barrier_destroy(recv); `}
+ fun destroy `{ pthread_barrier_destroy(self); `}
- fun wait `{ pthread_barrier_wait(recv); `}
+ fun wait `{ pthread_barrier_wait(self); `}
end
fun join: nullable Object `{
void *thread_return;
- pthread_join(*recv, &thread_return);
+ pthread_join(*self, &thread_return);
if(thread_return == NULL) thread_return = null_Object();
return (nullable_Object)thread_return;
`}
- fun equal(other: NativePthread): Bool `{ return pthread_equal(*recv, *other); `}
+ fun equal(other: NativePthread): Bool `{ return pthread_equal(*self, *other); `}
- fun kill(signal: Int) `{ pthread_kill(*recv, signal); `}
+ fun kill(signal: Int) `{ pthread_kill(*self, signal); `}
end
private extern class NativePthreadAttr in "C" `{ pthread_attr_t * `}
`}
fun destroy `{
- pthread_attr_destroy(recv);
+ pthread_attr_destroy(self);
`}
# Most features of this class are still TODO
return mutex;
`}
- fun destroy `{ pthread_mutex_destroy(recv); `}
+ fun destroy `{ pthread_mutex_destroy(self); `}
- fun lock `{ pthread_mutex_lock(recv); `}
- fun try_lock: Bool `{ return pthread_mutex_trylock(recv); `}
- fun unlock `{ pthread_mutex_unlock(recv); `}
+ fun lock `{ pthread_mutex_lock(self); `}
+ fun try_lock: Bool `{ return pthread_mutex_trylock(self); `}
+ fun unlock `{ pthread_mutex_unlock(self); `}
end
private extern class NativePthreadMutexAttr in "C" `{ pthread_mutexattr_t * `}
return attr;
`}
- fun destroy `{ pthread_mutexattr_destroy(recv); `}
+ fun destroy `{ pthread_mutexattr_destroy(self); `}
- fun set_type_normal `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_NORMAL); `}
- fun set_type_recursive `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_RECURSIVE); `}
- fun set_type_errorcheck `{ pthread_mutexattr_settype(recv, PTHREAD_MUTEX_ERRORCHECK); `}
+ fun set_type_normal `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_NORMAL); `}
+ fun set_type_recursive `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_RECURSIVE); `}
+ fun set_type_errorcheck `{ pthread_mutexattr_settype(self, PTHREAD_MUTEX_ERRORCHECK); `}
# pthread_mutexattr_setpshared
# pthread_mutexattr_setprotocol
`}
fun get: nullable Object `{
- void *val = pthread_getspecific(*recv);
+ void *val = pthread_getspecific(*self);
if (val == NULL) val = null_Object();
return val;
`}
fun set(val: nullable Object) `{
- pthread_setspecific(*recv, val);
+ pthread_setspecific(*self, val);
`}
end
return NULL;
`}
- fun destroy `{ pthread_cond_destroy(recv); `}
+ fun destroy `{ pthread_cond_destroy(self); `}
- fun signal `{ pthread_cond_signal(recv); `}
+ fun signal `{ pthread_cond_signal(self); `}
- fun broadcast `{ pthread_cond_broadcast(recv); `}
+ fun broadcast `{ pthread_cond_broadcast(self); `}
- fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(recv, mutex); `}
+ fun wait(mutex: NativePthreadMutex) `{ pthread_cond_wait(self, mutex); `}
end
#
# Update `self` clock.
fun update `{
- clock_gettime( CLOCK_MONOTONIC, recv );
+ clock_gettime(CLOCK_MONOTONIC, self);
`}
# Substract a Timespec from `self`.
# Number of whole seconds of elapsed time.
fun sec : Int `{
- return recv->tv_sec;
+ return self->tv_sec;
`}
# Rest of the elapsed time (a fraction of a second).
#
# Number of nanoseconds.
fun nanosec : Int `{
- return recv->tv_nsec;
+ return self->tv_nsec;
`}
# Seconds in Float
super Attributes
private var data = new Array[String]
- redef var length: Int = 0
+ redef var length = 0
- redef fun uri(index: Int): nullable String do
+ redef fun uri(index) do
if index >= 0 and index < length then
return data[index * 5]
else
end
end
- redef fun local_name(index: Int): nullable String do
+ redef fun local_name(index) do
if index >= 0 and index < length then
return data[index * 5 + 1]
else
end
end
- redef fun qname(index: Int): nullable String do
+ redef fun qname(index) do
if index >= 0 and index < length then
return data[index * 5 + 2]
else
# are not available.
#
# SEE: `length`
- redef fun type_of(index): nullable String do
+ redef fun type_of(index) do
if index isa Int then
if index >= 0 and index < length then
return data[index * 5 + 3]
# are not available.
#
# SEE: `length`
- redef fun value_of(index): nullable String do
+ redef fun value_of(index) do
if index isa Int then
if index >= 0 and index < length then
return data[index * 5 + 4]
#
# The index of the attribute, or -1 if it does not
# appear in the list.
- redef fun index_ns(uri: String, local_name: String): Int do
+ redef fun index_ns(uri, local_name) do
var i = 0
if "" != local_name then
#
# The index of the attribute, or -1 if it does not
# appear in the list.
- redef fun index_of(qname: String): Int do
+ redef fun index_of(qname) do
var i = 0
if "" != qname then
# The attribute type as a string, or `null` if the
# attribute is not in the list or if Namespace
# processing is not being performed.
- redef fun type_ns(uri: String, local_name: String): nullable String do
+ redef fun type_ns(uri, local_name) do
var i = 0
if "" != local_name then
# The attribute value as a string, or `null` if the
# attribute is not in the list or if Namespace
# processing is not being performed.
- redef fun value_ns(uri: String, local_name: String): nullable String do
+ redef fun value_ns(uri, local_name) do
var i = 0
if "" != local_name then
# can use it to make a persistent snapshot of a locator at any
# point during a document parse:
#
-# import sax::helpers::sax_locator_impl
-# import sax::content_handler
+# ~~~nitish
+# import sax::helpers::sax_locator_impl
+# import sax::content_handler
#
-# class Example super ContentHandler
-# private var locator: SAXLocator
-# private var start_loc: nullable SAXLocator = null
+# class Example super ContentHandler
+# private var locator: SAXLocator
+# private var start_loc: nullable SAXLocator = null
#
-# redef fun start_document do
-# # save the location of the start of the document
-# # for future use.
-# start_loc = new SAXLocatorImpl.from(locator)
-# end
+# redef fun start_document do
+# # save the location of the start of the document
+# # for future use.
+# start_loc = new SAXLocatorImpl.from(locator)
# end
+# end
+# ~~~
#
# Normally, parser writers will not use this class, since it
# is more efficient to provide location information only when
# Note: The original source code and documentation of this class comes, in part,
# from [SAX 2.0](http://www.saxproject.org).
class SAXLocatorImpl super SAXLocator
- redef var public_id: nullable String = null is writable
- redef var system_id: nullable String = null is writable
- redef var line_number: Int = -1 is writable
- redef var column_number: Int = -1 is writable
+ redef var public_id = null is writable
+ redef var system_id = null is writable
+ redef var line_number = -1 is writable
+ redef var column_number = -1 is writable
# Zero-argument constructor.
#
# XMLFilter
- redef var parent: nullable XMLReader = null is writable
+ redef var parent = null is writable
# XMLReader
- redef var entity_resolver: nullable EntityResolver = null is writable
- redef var dtd_handler: nullable DTDHandler = null is writable
- redef var content_handler: nullable ContentHandler = null is writable
- redef var error_handler: nullable ErrorHandler = null is writable
+ redef var entity_resolver = null is writable
+ redef var dtd_handler = null is writable
+ redef var content_handler = null is writable
+ redef var error_handler = null is writable
############################################################################
parent = parent_reader
end
- redef fun feature_recognized(name: String): Bool do
+ redef fun feature_recognized(name) do
if parent == null then
return false
else
end
end
- redef fun feature_readable(name: String): Bool do
+ redef fun feature_readable(name) do
if parent == null then
return false
else
end
end
- redef fun feature_writable(name: String): Bool do
+ redef fun feature_writable(name) do
if parent == null then
return false
else
# SEE: `feature_recognized`
#
# SEE: `feature_readable`
- redef fun feature(name: String): Bool do
+ redef fun feature(name) do
assert sax_recognized: parent != null else
sys.stderr.write("Feature: {name}\n")
end
# SEE: `feature_recognized`
#
# SEE: `feature_writable`
- redef fun feature=(name: String, value: Bool) do
+ redef fun feature=(name, value) do
assert sax_recognized: parent != null else
sys.stderr.write("Feature: {name}\n")
end
parent.feature(name) = value
end
- redef fun property_recognized(name: String): Bool do
+ redef fun property_recognized(name) do
if parent == null then
return false
else
end
end
- redef fun property_readable(name: String): Bool do
+ redef fun property_readable(name) do
if parent == null then
return false
else
end
end
- redef fun property_writable(name: String): Bool do
+ redef fun property_writable(name) do
if parent == null then
return false
else
# SEE: `property_recognized`
#
# SEE: `property_readable`
- redef fun property(name: String): nullable Object do
+ redef fun property(name) do
assert sax_recognized: parent != null else
sys.stderr.write("Property: {name}\n")
end
# SEE: `property_recognized`
#
# SEE: `property_writable`
- redef fun property=(name: String, value: nullable Object) do
+ redef fun property=(name, value) do
assert sax_recognized: parent != null else
sys.stderr.write("Property: {name}\n")
end
parent.property(name) = value
end
- redef fun parse(input: InputSource) do
+ redef fun parse(input) do
setup_parse
parent.parse(input)
end
- redef fun parse_file(system_id: String) do
+ redef fun parse_file(system_id) do
var source = new InputSource
source.system_id = system_id
############################################################################
# EntityResolver
- redef fun resolve_entity(public_id: nullable String,
- system_id: nullable String):
- nullable InputSource do
+ redef fun resolve_entity(public_id, system_id) do
if entity_resolver == null then
return null
else
############################################################################
# DTDHandler
- redef fun notation_decl(name: String, public_id: String,
- system_id: String) do
+ redef fun notation_decl(name, public_id, system_id) do
if dtd_handler != null then
dtd_handler.notation_decl(name, public_id, system_id)
end
end
- redef fun unparsed_entity_decl(name: String, public_id: String,
- system_id: String) do
+ redef fun unparsed_entity_decl(name, public_id, system_id) do
if dtd_handler != null then
dtd_handler.unparsed_entity_decl(name, public_id, system_id)
end
############################################################################
# ContentHandler
- redef fun document_locator=(locator: SAXLocator) do
+ redef fun document_locator=(locator) do
if content_handler != null then
content_handler.document_locator = locator
end
end
end
- redef fun start_prefix_mapping(prefix: String, uri: String) do
+ redef fun start_prefix_mapping(prefix, uri) do
if content_handler != null then
content_handler.start_prefix_mapping(prefix, uri)
end
end
- redef fun end_prefix_mapping(prefix: String) do
+ redef fun end_prefix_mapping(prefix) do
if content_handler != null then
content_handler.end_prefix_mapping(prefix)
end
end
- redef fun start_element(uri: String, local_name: String, qname: String,
- atts: Attributes) do
+ redef fun start_element(uri, local_name, qname, atts) do
if content_handler != null then
content_handler.start_element(uri, local_name, qname, atts)
end
end
- redef fun end_element(uri: String, local_name: String, qname: String) do
+ redef fun end_element(uri, local_name, qname) do
if content_handler != null then
content_handler.end_element(uri, local_name, qname)
end
end
- redef fun characters(str: String) do
+ redef fun characters(str) do
if content_handler != null then
content_handler.characters(str)
end
end
- redef fun ignorable_whitespace(str: String) do
+ redef fun ignorable_whitespace(str) do
if content_handler != null then
content_handler.ignorable_whitespace(str)
end
end
- redef fun processing_instruction(target: String, data: nullable String) do
+ redef fun processing_instruction(target, data) do
if content_handler != null then
content_handler.processing_instruction(target, data)
end
end
- redef fun skipped_entity(name: String) do
+ redef fun skipped_entity(name) do
if content_handler != null then
content_handler.skipped_entity(name)
end
############################################################################
# ErrorHandler
- redef fun warning(exception: SAXParseException) do
+ redef fun warning(exception) do
if error_handler != null then
error_handler.warning(exception)
end
end
- redef fun error(exception: SAXParseException) do
+ redef fun error(exception) do
if error_handler != null then
error_handler.error(exception)
end
end
- redef fun fatal_error(exception: SAXParseException) do
+ redef fun fatal_error(exception) do
if error_handler != null then
error_handler.fatal_error(exception)
else
private var model = new XophonReaderModel
private var lexer: XophonLexer is noinit
- redef fun entity_resolver: nullable EntityResolver do return model.entity_resolver
- redef fun entity_resolver=(entity_resolver: nullable EntityResolver) do
+ redef fun entity_resolver do return model.entity_resolver
+ redef fun entity_resolver=(entity_resolver) do
model.entity_resolver = entity_resolver
end
- redef fun dtd_handler: nullable DTDHandler do return model.dtd_handler
- redef fun dtd_handler=(dtd_handler: nullable DTDHandler) do
+ redef fun dtd_handler do return model.dtd_handler
+ redef fun dtd_handler=(dtd_handler) do
model.dtd_handler = dtd_handler
end
- redef fun content_handler: nullable ContentHandler do return model.content_handler
- redef fun content_handler=(content_handler: nullable ContentHandler) do
+ redef fun content_handler do return model.content_handler
+ redef fun content_handler=(content_handler) do
model.content_handler = content_handler
end
- redef fun error_handler: nullable ErrorHandler do return model.error_handler
- redef fun error_handler=(error_handler: nullable ErrorHandler) do
+ redef fun error_handler do return model.error_handler
+ redef fun error_handler=(error_handler) do
model.error_handler = error_handler
end
- redef fun feature_recognized(name: String): Bool do
+ redef fun feature_recognized(name) do
return model.feature_recognized(name)
end
- redef fun feature_readable(name: String): Bool do
+ redef fun feature_readable(name) do
return model.feature_readable(name)
end
- redef fun feature_writable(name: String): Bool do
+ redef fun feature_writable(name) do
return model.feature_readable(name)
end
- redef fun feature(name: String): Bool do return model.feature(name)
- redef fun feature=(name: String, value: Bool) do model.feature(name) = value
+ redef fun feature(name) do return model.feature(name)
+ redef fun feature=(name, value) do model.feature(name) = value
- redef fun property_recognized(name: String): Bool do
+ redef fun property_recognized(name) do
return model.property_recognized(name)
end
- redef fun property_readable(name: String): Bool do
+ redef fun property_readable(name) do
return model.property_readable(name)
end
- redef fun property_writable(name: String): Bool do
+ redef fun property_writable(name) do
return model.property_writable(name)
end
- redef fun property(name: String): nullable Object do
+ redef fun property(name) do
return model.property(name)
end
- redef fun property=(name: String, value: nullable Object) do
+ redef fun property=(name, value) do
model.property(name) = value
end
- redef fun parse(input: InputSource) do
+ redef fun parse(input) do
var system_id: nullable MaybeError[String, Error] = null
model.locator = new SAXLocatorImpl
end
end
- redef fun parse_file(system_id: String) do
+ redef fun parse_file(system_id) do
parse(new InputSource.with_system_id(system_id))
end
############################################################################
# XMLReader
- redef fun property(name: String): nullable Object do
+ redef fun property(name) do
assert sax_recognized: parent != null else
sys.stderr.write("Property: {name}\n")
end
end
end
- redef fun property=(name: String, value: nullable Object) do
+ redef fun property=(name, value) do
assert sax_recognized: parent != null else
sys.stderr.write("Property: {name}\n")
end
end
end
- redef fun parse(input: InputSource) do
+ redef fun parse(input) do
assert parent_is_not_null: parent != 0 else
sys.stderr.write("No parent for filter.")
end
############################################################################
# EntityResolver
- redef fun resolve_entity(public_id: nullable String,
- system_id: nullable String):
- nullable InputSource do
+ redef fun resolve_entity(public_id, system_id) do
log.push(["resolve_entity",
public_id or else "^NULL",
system_id or else "^NULL"])
############################################################################
# DTDHandler
- redef fun notation_decl(name: String, public_id: String,
- system_id: String) do
+ redef fun notation_decl(name, public_id, system_id) do
log.push(["notation_decl", name, public_id, system_id])
super
end
- redef fun unparsed_entity_decl(name: String, public_id: String,
- system_id: String) do
+ redef fun unparsed_entity_decl(name, public_id, system_id) do
log.push(["unparsed_entity_decl", name, public_id, system_id])
super
end
############################################################################
# ContentHandler
- redef fun document_locator=(locator: SAXLocator) do
+ redef fun document_locator=(locator) do
log.push(["document_locator=",
locator.public_id or else "^NULL",
locator.system_id or else "^NULL",
super
end
- redef fun start_prefix_mapping(prefix: String, uri: String) do
+ redef fun start_prefix_mapping(prefix, uri) do
log.push(["start_prefix_mapping", prefix, uri])
super
end
- redef fun end_prefix_mapping(prefix: String) do
+ redef fun end_prefix_mapping(prefix) do
log.push(["end_prefix_mapping", prefix])
super
end
- redef fun start_element(uri: String, local_name: String, qname: String,
- atts: Attributes) do
+ redef fun start_element(uri, local_name, qname, atts) do
var entry = new Array[String]
var i = 0
var length = atts.length
super
end
- redef fun end_element(uri: String, local_name: String, qname: String) do
+ redef fun end_element(uri, local_name, qname) do
log.push(["end_element", uri, local_name, qname])
super
end
- redef fun characters(str: String) do
+ redef fun characters(str) do
log.push(["characters", str])
super
end
- redef fun ignorable_whitespace(str: String) do
+ redef fun ignorable_whitespace(str) do
log.push(["ignorable_witespace", str])
super
end
- redef fun processing_instruction(target: String, data: nullable String) do
+ redef fun processing_instruction(target, data) do
log.push(["processing_instruction", target, data or else "^NULL"])
super
end
- redef fun skipped_entity(name: String) do
+ redef fun skipped_entity(name) do
log.push(["skipped_entity", name])
super
end
############################################################################
# ErrorHandler
- redef fun warning(exception: SAXParseException) do
+ redef fun warning(exception) do
log.push(["warning", exception.full_message])
super
end
- redef fun error(exception: SAXParseException) do
+ redef fun error(exception) do
log.push(["error", exception.full_message])
super
end
- redef fun fatal_error(exception: SAXParseException) do
+ redef fun fatal_error(exception) do
log.push(["fatal_error", exception.full_message])
if error_handler != null then
error_handler.fatal_error(exception)
############################################################################
# DeclHandler
- redef fun element_decl(name: String, model: String) do
+ redef fun element_decl(name, model) do
log.push(["element_decl", name, model])
if decl_handler != null then
decl_handler.element_decl(name, model)
end
end
- redef fun attribute_decl(element_name: String,
- attribute_name: String,
- attribute_type: String,
- mode: nullable String,
- value: nullable String) do
+ redef fun attribute_decl(element_name, attribute_name, attribute_type, mode, value) do
log.push(["attribute_decl",
element_name,
attribute_name,
end
end
- redef fun internal_entity_decl(name: String, value: String) do
+ redef fun internal_entity_decl(name, value) do
log.push(["internal_entity_decl", name, value])
if decl_handler != null then
decl_handler.internal_entity_decl(name, value)
end
end
- redef fun external_entity_decl(name: String, value: String) do
+ redef fun external_entity_decl(name, value) do
log.push(["external_entity_decl", name, value])
if decl_handler != null then
decl_handler.external_entity_decl(name, value)
############################################################################
# LexicalHandler
- redef fun start_dtd(name: String, public_id: nullable String,
- system_id: nullable String) do
+ redef fun start_dtd(name, public_id, system_id) do
log.push(["start_dtd", name,
public_id or else "^NULL",
system_id or else "^NULL"])
end
end
- redef fun start_entity(name: String) do
+ redef fun start_entity(name) do
log.push(["start_entity", name])
if lexical_handler != null then
lexical_handler.start_entity(name)
end
end
- redef fun end_entity(name: String) do
+ redef fun end_entity(name) do
log.push(["end_entity", name])
if lexical_handler != null then
lexical_handler.end_entity(name)
end
end
- redef fun comment(str: String) do
+ redef fun comment(str) do
log.push(["comment", str])
if lexical_handler != null then
lexical_handler.comment(str)
TTF_Quit();
`}
- redef fun finish `{ SDL_Flip(recv); `}
+ redef fun finish `{ SDL_Flip(self); `}
# Clear the entire window with given RGB color (integer values)
fun clear_int(r, g, b: Int) `{
- SDL_FillRect(recv, NULL, SDL_MapRGB(recv->format,r,g,b));
+ SDL_FillRect(self, NULL, SDL_MapRGB(self->format,r,g,b));
`}
- redef fun width: Int `{ return recv->w; `}
- redef fun height: Int `{ return recv->h; `}
+ redef fun width: Int `{ return self->w; `}
+ redef fun height: Int `{ return self->h; `}
# Fill a rectangle with given color
fun fill_rect(rect: SDLRectangle, r, g, b: Int) `{
- SDL_FillRect(recv, rect, SDL_MapRGB(recv->format,r,g,b));
+ SDL_FillRect(self, rect, SDL_MapRGB(self->format,r,g,b));
`}
redef fun clear(r, g, b: Float) `{
ri = (Uint8)r*255;
gi = (Uint8)g*255;
bi = (Uint8)b*255;
- SDL_FillRect(recv, NULL, SDL_MapRGB(recv->format,ri,gi,bi));
+ SDL_FillRect(self, NULL, SDL_MapRGB(self->format,ri,gi,bi));
`}
# SDL events since the last call to this method
dst.w = 0;
dst.h = 0;
- SDL_BlitSurface(img, NULL, recv, &dst);
+ SDL_BlitSurface(img, NULL, self, &dst);
`}
redef fun blit_centered(img, x, y)
fun save_to_file(path: String) import String.to_cstring `{ `}
# Destroy the image and free the memory
- redef fun destroy `{ SDL_FreeSurface(recv); `}
+ redef fun destroy `{ SDL_FreeSurface(self); `}
- redef fun width: Int `{ return recv->w; `}
- redef fun height: Int `{ return recv->h; `}
+ redef fun width: Int `{ return self->w; `}
+ redef fun height: Int `{ return self->h; `}
fun is_ok: Bool do return not address_is_null
# Returns a reference to the pixels of the texture
- fun pixels: NativeCByteArray `{ return recv->pixels; `}
+ fun pixels: NativeCByteArray `{ return self->pixels; `}
# Does this texture has an alpha mask?
- fun amask: Bool `{ return recv->format->Amask; `}
+ fun amask: Bool `{ return self->format->Amask; `}
end
# A simple rectangle
return rect;
`}
- fun x=(v: Int) `{ recv->x = (Sint16)v; `}
- fun x: Int `{ return recv->x; `}
+ fun x=(v: Int) `{ self->x = (Sint16)v; `}
+ fun x: Int `{ return self->x; `}
- fun y=(v: Int) `{ recv->y = (Sint16)v; `}
- fun y: Int `{ return recv->y; `}
+ fun y=(v: Int) `{ self->y = (Sint16)v; `}
+ fun y: Int `{ return self->y; `}
- fun w=(v: Int) `{ recv->w = (Uint16)v; `}
- fun w: Int `{ return recv->w; `}
+ fun w=(v: Int) `{ self->w = (Uint16)v; `}
+ fun w: Int `{ return self->w; `}
- fun h=(v: Int) `{ recv->h = (Uint16)v; `}
- fun h: Int `{ return recv->h; `}
+ fun h=(v: Int) `{ self->h = (Uint16)v; `}
+ fun h: Int `{ return self->h; `}
end
interface SDLInputEvent
end
redef class Int
- fun delay `{ SDL_Delay(recv); `}
+ fun delay `{ SDL_Delay(self); `}
end
# Class to load and use TTF_Font
return font;
`}
- fun destroy `{ TTF_CloseFont(recv); `}
+ fun destroy `{ TTF_CloseFont(self); `}
# Create a String with the specified color, return an SDLImage
fun render(text: String, r, g, b: Int): SDLImage import String.to_cstring `{
color.b = b;
ctext = String_to_cstring(text);
- if(!(text_surface=TTF_RenderText_Blended(recv, ctext, color)))
+ if(!(text_surface=TTF_RenderText_Blended(self, ctext, color)))
{
fprintf(stderr, "SDL TFF error: %s\n", TTF_GetError());
exit(1);
# Maximum pixel height of all glyphs of this font.
fun height: Int `{
- return TTF_FontHeight(recv);
+ return TTF_FontHeight(self);
`}
fun ascent: Int `{
- return TTF_FontAscent(recv);
+ return TTF_FontAscent(self);
`}
fun descent: Int `{
- return TTF_FontDescent(recv);
+ return TTF_FontDescent(self);
`}
# Get the recommended pixel height of a rendered line of text of the loaded font. This is usually larger than the Font.height.
fun line_skip: Int `{
- return TTF_FontLineSkip(recv);
+ return TTF_FontLineSkip(self);
`}
# Return true is the font used fixed width for each char
fun is_fixed_width: Bool `{
- return TTF_FontFaceIsFixedWidth(recv);
+ return TTF_FontFaceIsFixedWidth(self);
`}
# Return the family name of the font
fun family_name: nullable String import String.to_cstring, String.as nullable `{
- char *fn = TTF_FontFaceFamilyName(recv);
+ char *fn = TTF_FontFaceFamilyName(self);
if (fn == NULL)
return null_String();
# Return the style name of the font
fun style_name: nullable String import String.to_cstring, String.as nullable `{
- char *sn = TTF_FontFaceStyleName(recv);
+ char *sn = TTF_FontFaceStyleName(self);
if (sn == NULL)
return null_String();
fun width_of(text: String): Int import NativeString.to_s `{
char *ctext = String_to_cstring(text);
int w;
- if (TTF_SizeText(recv, ctext, &w, NULL))
+ if (TTF_SizeText(self, ctext, &w, NULL))
{
fprintf(stderr, "SDL TFF error: %s\n", TTF_GetError());
exit(1);
# Returns the handle of this window on a X11 window system
fun x11_window_handle: Pointer `{
- return (void*)recv->info.x11.window;
+ return (void*)self->info.x11.window;
`}
end
# Poll and event into `self`
#
# Returns `true` if an event was available.
- fun poll_event: Bool `{ return SDL_PollEvent(recv); `}
+ fun poll_event: Bool `{ return SDL_PollEvent(self); `}
# Get a reference to the data at `self` as a precise `SDLEvent`
#
end
# Is this a quit event?
- fun is_quit: Bool `{ return recv->type == SDL_QUIT; `}
+ fun is_quit: Bool `{ return self->type == SDL_QUIT; `}
# Get a reference to data at `self` as a `SDLQuitEvent`
- fun to_quit: SDLQuitEvent `{ return recv; `}
+ fun to_quit: SDLQuitEvent `{ return self; `}
# Is this a mouse motion event?
- fun is_mouse_motion: Bool `{ return recv->type == SDL_MOUSEMOTION; `}
+ fun is_mouse_motion: Bool `{ return self->type == SDL_MOUSEMOTION; `}
# Get a reference to data at `self` as a `SDLMouseMotionEvent`
- fun to_mouse_motion: SDLMouseMotionEvent `{ return recv; `}
+ fun to_mouse_motion: SDLMouseMotionEvent `{ return self; `}
# Is this a mouse button down event?
- fun is_mouse_button_down: Bool `{ return recv->type == SDL_MOUSEBUTTONDOWN; `}
+ fun is_mouse_button_down: Bool `{ return self->type == SDL_MOUSEBUTTONDOWN; `}
# Get a reference to data at `self` as a `SDLMouseButtonDownEvent`
- fun to_mouse_button_down: SDLMouseButtonDownEvent `{ return recv; `}
+ fun to_mouse_button_down: SDLMouseButtonDownEvent `{ return self; `}
# Is this a mouse button up event?
- fun is_mouse_button_up: Bool `{ return recv->type == SDL_MOUSEBUTTONUP; `}
+ fun is_mouse_button_up: Bool `{ return self->type == SDL_MOUSEBUTTONUP; `}
# Get a reference to data at `self` as a `SDLMouseButtonUpEvent`
- fun to_mouse_button_up: SDLMouseButtonUpEvent `{ return recv; `}
+ fun to_mouse_button_up: SDLMouseButtonUpEvent `{ return self; `}
# TODO other SDL events:
#
# four fields of each events are common to all of them.
# Which mouse, pointer or finger raised this event
- fun which: Int `{ return recv->motion.which; `}
+ fun which: Int `{ return self->motion.which; `}
end
# A mouse motion event
super SDLMouseEvent
# X coordinate on screen of this event
- fun x: Int `{ return recv->motion.x; `}
+ fun x: Int `{ return self->motion.x; `}
# Y coordinate on screen of this event
- fun y: Int `{ return recv->motion.y; `}
+ fun y: Int `{ return self->motion.y; `}
# Difference on the X axis between this event and the previous one
- fun xrel: Int `{ return recv->motion.xrel; `}
+ fun xrel: Int `{ return self->motion.xrel; `}
# Difference on the Y axis between this event and the previous one
- fun yrel: Int `{ return recv->motion.yrel; `}
+ fun yrel: Int `{ return self->motion.yrel; `}
end
# A mouse button event
super SDLMouseEvent
# X coordinate on screen of this event
- fun x: Int `{ return recv->button.x; `}
+ fun x: Int `{ return self->button.x; `}
# Y coordinate on screen of this event
- fun y: Int `{ return recv->button.y; `}
+ fun y: Int `{ return self->button.y; `}
end
# A mouse button release event
new `{ return 0; `}
# Add the JPG support to this flag set
- fun jpg: SDLImgInitFlags `{ return recv | IMG_INIT_JPG; `}
+ fun jpg: SDLImgInitFlags `{ return self | IMG_INIT_JPG; `}
# Add the PNG support to this flag set
- fun png: SDLImgInitFlags `{ return recv | IMG_INIT_PNG; `}
+ fun png: SDLImgInitFlags `{ return self | IMG_INIT_PNG; `}
# Add the TIF support to this flag set
- fun tif: SDLImgInitFlags `{ return recv | IMG_INIT_TIF; `}
+ fun tif: SDLImgInitFlags `{ return self | IMG_INIT_TIF; `}
# Add the WEBP support to this flag set
- fun webp: SDLImgInitFlags `{ return recv | IMG_INIT_WEBP; `}
+ fun webp: SDLImgInitFlags `{ return self | IMG_INIT_WEBP; `}
end
new `{ return 0; `}
# Add the timer subsystem
- fun timer: SDLInitFlags `{ return recv | SDL_INIT_TIMER; `}
+ fun timer: SDLInitFlags `{ return self | SDL_INIT_TIMER; `}
# Add the audio subsystem
- fun audio: SDLInitFlags `{ return recv | SDL_INIT_AUDIO; `}
+ fun audio: SDLInitFlags `{ return self | SDL_INIT_AUDIO; `}
# Add the video subsystem
- fun video: SDLInitFlags `{ return recv | SDL_INIT_VIDEO; `}
+ fun video: SDLInitFlags `{ return self | SDL_INIT_VIDEO; `}
# Add the joystick subsystem
#
# Implied by `gamecontroller`
- fun joystick: SDLInitFlags `{ return recv | SDL_INIT_JOYSTICK; `}
+ fun joystick: SDLInitFlags `{ return self | SDL_INIT_JOYSTICK; `}
# Add the haptic subsystem
- fun haptic: SDLInitFlags `{ return recv | SDL_INIT_HAPTIC; `}
+ fun haptic: SDLInitFlags `{ return self | SDL_INIT_HAPTIC; `}
# Add the gamecontroller subsystem
- fun gamecontroller: SDLInitFlags `{ return recv | SDL_INIT_GAMECONTROLLER; `}
+ fun gamecontroller: SDLInitFlags `{ return self | SDL_INIT_GAMECONTROLLER; `}
# Add the events subsystem
#
# Implied by `video` and `joystick`
- fun events: SDLInitFlags `{ return recv | SDL_INIT_EVENTS; `}
+ fun events: SDLInitFlags `{ return self | SDL_INIT_EVENTS; `}
# Add all subsystems
- fun everything: SDLInitFlags `{ return recv | SDL_INIT_EVERYTHING; `}
+ fun everything: SDLInitFlags `{ return self | SDL_INIT_EVERYTHING; `}
# Is this flag set empty?
- fun is_empty: Bool `{ return recv == 0; `}
+ fun is_empty: Bool `{ return self == 0; `}
# TODO add all other is_
end
fun initialized: Bool do return not address_is_null
# Destroy this window
- fun destroy `{ SDL_DestroyWindow(recv); `}
+ fun destroy `{ SDL_DestroyWindow(self); `}
# Get the `SDLWindowFlags` describing the status of the window
- fun flags: SDLWindowFlags `{ return SDL_GetWindowFlags(recv); `}
+ fun flags: SDLWindowFlags `{ return SDL_GetWindowFlags(self); `}
# Show a simple message box
#
# Similar to `sys.sdl.show_simple_message_box` but attached to this window
fun show_simple_message_box(level: SDLMessageBoxFlags, title, content: NativeString) `{
- SDL_ShowSimpleMessageBox(level, title, content, recv);
+ SDL_ShowSimpleMessageBox(level, title, content, self);
`}
# Set the icon of this window
- fun icon=(icon: SDLSurface) `{ SDL_SetWindowIcon(recv, icon); `}
+ fun icon=(icon: SDLSurface) `{ SDL_SetWindowIcon(self, icon); `}
end
# Flags for `SDLWindow::new` and returned by `SDLWindow::flags`
new `{ return 0; `}
# Add the flag requesting a fullscreen window
- fun fullscreen: SDLWindowFlags `{ return recv | SDL_WINDOW_FULLSCREEN; `}
+ fun fullscreen: SDLWindowFlags `{ return self | SDL_WINDOW_FULLSCREEN; `}
# Add the flag requesting a fullscreen window for the current desktop
- fun fullscreen_desktop: SDLWindowFlags `{ return recv | SDL_WINDOW_FULLSCREEN_DESKTOP; `}
+ fun fullscreen_desktop: SDLWindowFlags `{ return self | SDL_WINDOW_FULLSCREEN_DESKTOP; `}
# Add the flag requesting a window usable with an OpenGL context
- fun opengl: SDLWindowFlags `{ return recv | SDL_WINDOW_OPENGL; `}
+ fun opengl: SDLWindowFlags `{ return self | SDL_WINDOW_OPENGL; `}
# Add the flag requesting a hidden window
- fun hidden: SDLWindowFlags `{ return recv | SDL_WINDOW_HIDDEN; `}
+ fun hidden: SDLWindowFlags `{ return self | SDL_WINDOW_HIDDEN; `}
# Add the flag requesting a borderless window
- fun borderless: SDLWindowFlags `{ return recv | SDL_WINDOW_BORDERLESS; `}
+ fun borderless: SDLWindowFlags `{ return self | SDL_WINDOW_BORDERLESS; `}
# Add the flag requesting a resizable window
- fun resizable: SDLWindowFlags `{ return recv | SDL_WINDOW_RESIZABLE; `}
+ fun resizable: SDLWindowFlags `{ return self | SDL_WINDOW_RESIZABLE; `}
# Add the flag requesting a minimized window
- fun minimized: SDLWindowFlags `{ return recv | SDL_WINDOW_MINIMIZED; `}
+ fun minimized: SDLWindowFlags `{ return self | SDL_WINDOW_MINIMIZED; `}
# Add the flag requesting a maximimez window
- fun maximized: SDLWindowFlags `{ return recv | SDL_WINDOW_MAXIMIZED; `}
+ fun maximized: SDLWindowFlags `{ return self | SDL_WINDOW_MAXIMIZED; `}
# Add the flag to grab the input focus
- fun input_grabbed: SDLWindowFlags `{ return recv | SDL_WINDOW_INPUT_GRABBED; `}
+ fun input_grabbed: SDLWindowFlags `{ return self | SDL_WINDOW_INPUT_GRABBED; `}
# Add the flag to request a window using the system High-DPI mode
fun allow_highdpi: SDLWindowFlags `{
#if SDL_VERSION_ATLEAST(2, 0, 2)
- return recv | SDL_WINDOW_ALLOW_HIGHDPI;
+ return self | SDL_WINDOW_ALLOW_HIGHDPI;
#else
- return recv;
+ return self;
#endif
`}
# Is the window shown?
#
# Can only be queried because it is ignored by `SDLWindow::new`
- fun is_shown: Bool `{ return recv & SDL_WINDOW_SHOWN; `}
+ fun is_shown: Bool `{ return self & SDL_WINDOW_SHOWN; `}
# Does the window has the input focus?
#
# Can only be queried because it is ignored by `SDLWindow::new`
- fun has_input_focus: Bool `{ return recv & SDL_WINDOW_INPUT_FOCUS; `}
+ fun has_input_focus: Bool `{ return self & SDL_WINDOW_INPUT_FOCUS; `}
# Does the window has the mouse focus?
#
# Can only be queried because it is ignored by `SDLWindow::new`
- fun has_mouse_focus: Bool `{ return recv & SDL_WINDOW_MOUSE_FOCUS; `}
+ fun has_mouse_focus: Bool `{ return self & SDL_WINDOW_MOUSE_FOCUS; `}
# TODO add all other `is_` methods, as needed
end
redef universal Int
- # Suspend execution for `recv` milliseconds
- fun delay `{ SDL_Delay(recv); `}
+ # Suspend execution for `self` milliseconds
+ fun delay `{ SDL_Delay(self); `}
end
# A renderer, maybe software or hardware
`}
# Destroy this renderer
- fun destroy `{ SDL_DestroyRenderer(recv); `}
+ fun destroy `{ SDL_DestroyRenderer(self); `}
# Clear the rendering target with the current `draw_color`
- fun clear `{ SDL_RenderClear(recv); `}
+ fun clear `{ SDL_RenderClear(self); `}
# Copy the rectangle at `src` from `texture` to fill the `dst` at the rendering `target`
#
end
private fun native_copy(texture: SDLTexture, src, dst: SDLRect) `{
- SDL_RenderCopy(recv, texture, src, dst);
+ SDL_RenderCopy(self, texture, src, dst);
`}
# Update the screen with all rendering since the previous call
- fun present `{ SDL_RenderPresent(recv); `}
+ fun present `{ SDL_RenderPresent(self); `}
# Get the `SDLRendererInfo` for this renderer
- fun info_copy(out: SDLRendererInfo) `{ SDL_GetRendererInfo(recv, out); `}
+ fun info_copy(out: SDLRendererInfo) `{ SDL_GetRendererInfo(self, out); `}
# Set the drawing color
fun draw_color=(val: SDLColor) `{
- SDL_SetRenderDrawColor(recv, val->r, val->g, val->b, val->a);
+ SDL_SetRenderDrawColor(self, val->r, val->g, val->b, val->a);
`}
# Get the drawing color of this renderer
# Copy the drawing color of this renderer in `color`
fun draw_color_copy(color: SDLColor) `{
- SDL_GetRenderDrawColor(recv, &color->r, &color->g, &color->b, &color->a);
+ SDL_GetRenderDrawColor(self, &color->r, &color->g, &color->b, &color->a);
`}
# Fill a rectangle with the current `draw_color`
#
# If `rect.address_is_null` then fills the entire screen.
- fun fill_rect(rect: SDLRect) `{ SDL_RenderFillRect(recv, rect); `}
+ fun fill_rect(rect: SDLRect) `{ SDL_RenderFillRect(self, rect); `}
# Draw a rectangle with the current `draw_color`
- fun draw_rect(rect: SDLRect) `{ SDL_RenderDrawRect(recv, rect); `}
+ fun draw_rect(rect: SDLRect) `{ SDL_RenderDrawRect(self, rect); `}
# Draw a point with the current `draw_color`
- fun draw_point(x, y: Int) `{ SDL_RenderDrawPoint(recv, x, y); `}
+ fun draw_point(x, y: Int) `{ SDL_RenderDrawPoint(self, x, y); `}
# Draw a line with the current `draw_color`
- fun draw_line(x1, y1, x2, y2: Int) `{ SDL_RenderDrawLine(recv, x1, y1, x2, y2); `}
+ fun draw_line(x1, y1, x2, y2: Int) `{ SDL_RenderDrawLine(self, x1, y1, x2, y2); `}
# Set the viewport of this renderer
- fun viewport=(rect: SDLRect) `{ SDL_RenderSetViewport(recv, rect); `}
+ fun viewport=(rect: SDLRect) `{ SDL_RenderSetViewport(self, rect); `}
# Get the rendering target of this renderer
- fun target: SDLTexture `{ return SDL_GetRenderTarget(recv); `}
+ fun target: SDLTexture `{ return SDL_GetRenderTarget(self); `}
# Set the rendering target of this renderer
- fun target=(val: SDLTexture) `{ SDL_SetRenderTarget(recv, val); `}
+ fun target=(val: SDLTexture) `{ SDL_SetRenderTarget(self, val); `}
# TODO add other renderer related methods:
#
end
# The red component of this color `[0..255]`
- fun r: Int `{ return recv->r; `}
+ fun r: Int `{ return self->r; `}
# Set the red component of this color `[0..255]`
- fun r=(val: Int) `{ recv->r = val; `}
+ fun r=(val: Int) `{ self->r = val; `}
# The green component of this color `[0..255]`
- fun g: Int `{ return recv->g; `}
+ fun g: Int `{ return self->g; `}
# Set the green component of this color `[0..255]`
- fun g=(val: Int) `{ recv->g = val; `}
+ fun g=(val: Int) `{ self->g = val; `}
# The blue component of this color `[0..255]`
- fun b: Int `{ return recv->b; `}
+ fun b: Int `{ return self->b; `}
# Set the blue component of this color `[0..255]`
- fun b=(val: Int) `{ recv->b = val; `}
+ fun b=(val: Int) `{ self->b = val; `}
# The alpha component of this color `[0..255]`
- fun a: Int `{ return recv->a; `}
+ fun a: Int `{ return self->a; `}
# Set the ralpha component of this color `[0..255]`
- fun a=(val: Int) `{ recv->a = val; `}
+ fun a=(val: Int) `{ self->a = val; `}
# TODO implement the related `SDL_Palette` and related methods
end
new `{ return 0; `}
# Add the flag to request a software renderer
- fun software: SDLRendererFlags `{ return recv | SDL_RENDERER_SOFTWARE; `}
+ fun software: SDLRendererFlags `{ return self | SDL_RENDERER_SOFTWARE; `}
# Add the flag to request an accelerated renderer
#
# This is the default option.
- fun accelerated: SDLRendererFlags `{ return recv | SDL_RENDERER_ACCELERATED; `}
+ fun accelerated: SDLRendererFlags `{ return self | SDL_RENDERER_ACCELERATED; `}
# Add the flag to request a renderer where `SDLRenderer::present` is synchronized with the refresh rate
- fun presentvsync: SDLRendererFlags `{ return recv | SDL_RENDERER_PRESENTVSYNC; `}
+ fun presentvsync: SDLRendererFlags `{ return self | SDL_RENDERER_PRESENTVSYNC; `}
# Add the flag to request a renderer able to render to a texture
- fun targettexture: SDLRendererFlags `{ return recv | SDL_RENDERER_TARGETTEXTURE; `}
+ fun targettexture: SDLRendererFlags `{ return self | SDL_RENDERER_TARGETTEXTURE; `}
end
# A bitmap surface
# Load the BMP file at `path`
new load_bmp(path: NativeString) `{ return SDL_LoadBMP(path); `}
- redef fun free `{ SDL_FreeSurface(recv); `}
+ redef fun free `{ SDL_FreeSurface(self); `}
# Save this texture to a BMP file
- fun save_bmp(path: NativeString) `{ SDL_SaveBMP(recv, path); `}
+ fun save_bmp(path: NativeString) `{ SDL_SaveBMP(self, path); `}
end
# A loaded bitmap texture
`}
# Destroy this texture
- fun destroy `{ SDL_DestroyTexture(recv); `}
+ fun destroy `{ SDL_DestroyTexture(self); `}
# Width of this texture
fun width: Int `{
int val;
- SDL_QueryTexture(recv, NULL, NULL, &val, NULL);
+ SDL_QueryTexture(self, NULL, NULL, &val, NULL);
return val;
`}
# Height of this texture
fun height: Int `{
int val;
- SDL_QueryTexture(recv, NULL, NULL, NULL, &val);
+ SDL_QueryTexture(self, NULL, NULL, NULL, &val);
return val;
`}
end
# X coordinate of the top left corner
- fun x: Int `{ return recv->x; `}
+ fun x: Int `{ return self->x; `}
# Set the X coordinate of the top left corner
- fun x=(val: Int) `{ recv->x = val; `}
+ fun x=(val: Int) `{ self->x = val; `}
# Y coordinate of the top left corner
- fun y: Int `{ return recv->y; `}
+ fun y: Int `{ return self->y; `}
# Set the Y coordinate of the top left corner
- fun y=(val: Int) `{ recv->y = val; `}
+ fun y=(val: Int) `{ self->y = val; `}
# Width of this rectangle
- fun w: Int `{ return recv->w; `}
+ fun w: Int `{ return self->w; `}
# Set the width of this rectangle
- fun w=(val: Int) `{ recv->w = val; `}
+ fun w=(val: Int) `{ self->w = val; `}
# Height of this rectangle
- fun h: Int `{ return recv->h; `}
+ fun h: Int `{ return self->h; `}
# Set the height of this rectangle
- fun h=(val: Int) `{ recv->h = val; `}
+ fun h=(val: Int) `{ self->h = val; `}
# TODO implement other `SDLRect` related methods:
#
end
# X coordinate of this point
- fun x: Int `{ return recv->x; `}
+ fun x: Int `{ return self->x; `}
# Set the X coordinate of this point
- fun x=(val: Int) `{ recv->x = val; `}
+ fun x=(val: Int) `{ self->x = val; `}
# Y coordinate of this point
- fun y: Int `{ return recv->y; `}
+ fun y: Int `{ return self->y; `}
# Set the Y coordinate of this point
- fun y=(val: Int) `{ recv->y = val; `}
+ fun y=(val: Int) `{ self->y = val; `}
end
# Flag to set the icon in `sys.sdl.show_simple_message_box` and `SDLWindow::show_simple_message_box`
new malloc `{ return malloc(sizeof(SDL_RendererInfo)); `}
# Name of the renderer's driver
- fun name: NativeString `{ return (char*)recv->name; `}
+ fun name: NativeString `{ return (char*)self->name; `}
# Maximum texture width supported by the renderer
- fun max_texture_width: Int `{ return recv->max_texture_width; `}
+ fun max_texture_width: Int `{ return self->max_texture_width; `}
# Maximum texture height supported by the renderer
- fun max_texture_height: Int `{ return recv->max_texture_height; `}
+ fun max_texture_height: Int `{ return self->max_texture_height; `}
end
SDL_VERSION(&val->version);
- if(SDL_GetWindowWMInfo(recv, val) <= 0) {
+ if(SDL_GetWindowWMInfo(self, val) <= 0) {
free(val);
return NULL;
}
# Created using `SDLWindow::vm_info`
extern class SDLSysWMInfo `{ SDL_SysWMinfo * `}
# Is this an unknown window manager?
- fun is_unknown: Bool `{ return recv->subsystem == SDL_SYSWM_UNKNOWN; `}
+ fun is_unknown: Bool `{ return self->subsystem == SDL_SYSWM_UNKNOWN; `}
# Is this a Windows system?
- fun is_windows: Bool `{ return recv->subsystem == SDL_SYSWM_WINDOWS; `}
+ fun is_windows: Bool `{ return self->subsystem == SDL_SYSWM_WINDOWS; `}
# Is this the X11 window manager?
- fun is_x11: Bool `{ return recv->subsystem == SDL_SYSWM_X11; `}
+ fun is_x11: Bool `{ return self->subsystem == SDL_SYSWM_X11; `}
# Is this a direct DirectFB?
- fun is_direcfb: Bool `{ return recv->subsystem == SDL_SYSWM_DIRECTFB; `}
+ fun is_direcfb: Bool `{ return self->subsystem == SDL_SYSWM_DIRECTFB; `}
# Is this system an OS X?
- fun is_cocoa: Bool `{ return recv->subsystem == SDL_SYSWM_COCOA; `}
+ fun is_cocoa: Bool `{ return self->subsystem == SDL_SYSWM_COCOA; `}
# Is this system an iOS?
- fun is_uikit: Bool `{ return recv->subsystem == SDL_SYSWM_UIKIT; `}
+ fun is_uikit: Bool `{ return self->subsystem == SDL_SYSWM_UIKIT; `}
# It this window manager Wayland?
fun is_wayland: Bool `{
#if SDL_VERSION_ATLEAST(2, 0, 2)
- return recv->subsystem == SDL_SYSWM_WAYLAND;
+ return self->subsystem == SDL_SYSWM_WAYLAND;
#else
return 0;
#endif
# It this window manager Mir?
fun is_mir: Bool `{
#if SDL_VERSION_ATLEAST(2, 0, 3)
- return recv->subsystem == SDL_SYSWM_MIR;
+ return self->subsystem == SDL_SYSWM_MIR;
#else
return 0;
#endif
# Is this system a Windows RT?
fun is_winrt: Bool `{
#if SDL_VERSION_ATLEAST(2, 0, 3)
- return recv->subsystem == SDL_SYSWM_WINRT;
+ return self->subsystem == SDL_SYSWM_WINRT;
#else
return 0;
#endif
# Is this system an Android?
fun is_android: Bool `{
#if SDL_VERSION_ATLEAST(2, 0, 4)
- return recv->subsystem == SDL_SYSWM_ANDROID;
+ return self->subsystem == SDL_SYSWM_ANDROID;
#else
return 0;
#endif
#
# Require: `is_x11`
fun x11_window_handle: Pointer `{
- return (void*)recv->info.x11.window;
+ return (void*)self->info.x11.window;
`}
end
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Services for caching serialization engines
+module caching
+
+import serialization
+private import engine_tools
+
+# A `Serializer` with a `cache`
+abstract class CachingSerializer
+ super Serializer
+
+ # Cache of known objects
+ var cache = new SerializerCache is lazy, writable
+
+ # Link the cache of `self` with `deserializer`
+ #
+ # This allows reference objects by id when they are known by the other side
+ # of the stream.
+ #
+ # Use `cache` if it is a `DuplexCache`, otherwise create a new one.
+ fun link(deserializer: CachingDeserializer)
+ do
+ var mem = self.cache
+ if not mem isa DuplexCache then mem = new DuplexCache
+
+ self.cache = mem
+ deserializer.cache = mem
+ end
+end
+
+# A `Deserializer` with a `cache`
+abstract class CachingDeserializer
+ super Deserializer
+
+ # Cache of known objects
+ var cache = new DeserializerCache is lazy, writable
+end
+
+# Cache of sent objects
+#
+# Used by `Serializer` to avoid duplicating objects, by serializing them once,
+# then using a reference.
+class SerializerCache
+ # Map of already serialized objects to the reference id
+ private var sent: Map[Serializable, Int] = new StrictHashMap[Serializable, Int]
+
+ # Is `object` known?
+ fun has_object(object: Serializable): Bool do return sent.keys.has(object)
+
+ # Get the id for `object`
+ #
+ # Require: `has_object(object)`
+ fun id_for(object: Serializable): Int
+ do
+ assert sent.keys.has(object)
+ return sent[object]
+ end
+
+ # Get a new id for `object` and store it
+ #
+ # Require: `not has_object(object)`
+ fun new_id_for(object: Serializable): Int
+ do
+ var id = sent.length
+ sent[object] = id
+ return id
+ end
+end
+
+# Cache of received objects sorted by there reference id
+#
+# Used by `Deserializer` to find already deserialized objects by their reference.
+class DeserializerCache
+ # Map of references to already deserialized objects.
+ private var received: Map[Int, Object] = new StrictHashMap[Int, Object]
+
+ # Is there an object associated to `id`?
+ fun has_id(id: Int): Bool do return received.keys.has(id)
+
+ # Get the object associated to `id`
+ fun object_for(id: Int): nullable Object do return received[id]
+
+ # Associate `object` to `id`
+ fun []=(id: Int, object: Object) do received[id] = object
+end
+
+# A shared cache for serialization and deserialization
+class DuplexCache
+ super SerializerCache
+ super DeserializerCache
+
+ redef fun new_id_for(object)
+ do
+ var id = super
+ received[id] = object
+ return id
+ end
+
+ redef fun []=(id, object)
+ do
+ super
+ assert object isa Serializable
+ sent[object] = id
+ end
+end
module engine_tools
import serialization
+intrude import standard::collection::hash_collection
-# Maps instances to a value, uses `is_same_instance`
-#
-# Warning: This class does not implement all the services from `Map`.
+# Maps instances to a value, uses `is_same_serialized` and `serialization_hash`.
class StrictHashMap[K, V]
- super Map[K, V]
-
- # private
- var map = new HashMap[K, Array[Couple[K, V]]]
-
- redef var length = 0
-
- redef fun is_empty do return length == 0
+ super HashMap[K, V]
- # private
- fun node_at(key: K): nullable Couple[K, V]
+ redef fun index_at(k)
do
- if not map.keys.has(key) then return null
-
- var arr = map[key]
- for couple in arr do
- if couple.first.is_same_serialized(key) then
- return couple
- end
- end
+ if k == null then return 0
- return null
+ var i = k.serialization_hash % _capacity
+ if i < 0 then i = - i
+ return i
end
- redef fun [](key)
+ redef fun node_at_idx(i, k)
do
- var node = node_at(key)
- assert node != null
- return node.second
- end
-
- redef fun []=(key, value)
- do
- var node = node_at(key)
- if node != null then
- node.second = value
- return
+ var c = _array[i]
+ while c != null do
+ var ck = c._key
+ if ck.is_same_serialized(k) then
+ break
+ end
+ c = c._next_in_bucklet
end
-
- var arr
- if not map.keys.has(key) then
- arr = new Array[Couple[K, V]]
- map[key] = arr
- else arr = map[key]
-
- arr.add new Couple[K, V](key, value)
- self.length += 1
+ return c
end
-
- redef fun has_key(key) do return node_at(key) != null
end
#
# Used to determine if an object has already been serialized.
fun is_same_serialized(other: nullable Object): Bool do return is_same_instance(other)
+
+ # Hash value use for serialization
+ #
+ # Used in combination with `is_same_serialized`. If two objects are the same
+ # in a serialization context, they must have the same `serialization_hash`.
+ fun serialization_hash: Int do return object_id
end
# Instances of this class are not delayed and instead serialized immediately
redef class String super DirectSerializable end
redef class SimpleCollection[E] super Serializable end
redef class Map[K, V] super Serializable end
+
+redef class Couple[F, S]
+ super Serializable
+
+ redef init from_deserializer(v)
+ do
+ v.notify_of_creation self
+ var first = v.deserialize_attribute("first")
+ var second = v.deserialize_attribute("second")
+ init(first, second)
+ end
+
+ redef fun core_serialize_to(v)
+ do
+ v.serialize_attribute("first", first)
+ v.serialize_attribute("second", second)
+ end
+end
+
+redef class Container[E]
+ super Serializable
+
+ redef init from_deserializer(v)
+ do
+ v.notify_of_creation self
+ var item = v.deserialize_attribute("item")
+ init item
+ end
+
+ redef fun core_serialize_to(v)
+ do
+ v.serialize_attribute("item", first)
+ end
+end
sha1nfo s;
sha1_init(&s);
- sha1_write(&s, String_to_cstring(recv), String_length(recv));
+ sha1_write(&s, String_to_cstring(self), String_length(self));
uint8_t* digest = sha1_result(&s);
char* digested = malloc(21);
sha1nfo s;
sha1_init(&s);
- sha1_write(&s, String_to_cstring(recv), String_length(recv));
+ sha1_write(&s, String_to_cstring(self), String_length(self));
uint8_t* digest = sha1_result(&s);
char* ret_str = malloc(41);
if (last_handler != NULL)
SignalHandler_decr_ref(last_handler);
- nit_signals_list[signal].handler = recv;
- SignalHandler_incr_ref(recv);
+ nit_signals_list[signal].handler = self;
+ SignalHandler_incr_ref(self);
nit_signals_list[signal].safely = safely;
}
# Creates a socket connection to host `host` on port `port`
init connect(host: String, port: Int)
do
- _buffer = new FlatBuffer
+ _buffer = new NativeString(1024)
_buffer_pos = 0
socket = new NativeSocket.socket(new NativeSocketAddressFamilies.af_inet,
new NativeSocketTypes.sock_stream, new NativeSocketProtocolFamilies.pf_null)
# Creates a client socket, this is meant to be used by accept only
private init server_side(h: SocketAcceptResult)
do
- _buffer = new FlatBuffer
+ _buffer = new NativeString(1024)
_buffer_pos = 0
socket = h.socket
addrin = h.addr_in
# timeout : Time in milliseconds before stopping to wait for events
fun ready_to_read(timeout: Int): Bool
do
- if _buffer_pos < _buffer.length then return true
+ if _buffer_pos < _buffer_length then return true
if end_reached then return false
var events = [new NativeSocketPollValues.pollin]
return pollin(events, timeout).length != 0
end
# If socket.end_reached, nothing will happen
- redef fun write(msg: Text)
+ redef fun write(msg)
do
if closed then return
socket.write(msg.to_s)
socket.write_byte value
end
+ redef fun write_bytes(s) do
+ if closed then return
+ socket.write(s.to_s)
+ end
+
fun write_ln(msg: Text)
do
if end_reached then return
redef fun fill_buffer
do
- _buffer.clear
+ _buffer_length = 0
_buffer_pos = 0
if not connected then return
var read = socket.read
close
end_reached = true
end
- _buffer.append(read)
+ enlarge(_buffer_capacity + read.length)
+ read.copy_to_native(_buffer, read.length, 0, 0)
+ _buffer_length = read.length
+ end
+
+ fun enlarge(len: Int) do
+ if _buffer_capacity >= len then return
+ while _buffer_capacity < len do _buffer_capacity *= 2
+ var ns = new NativeString(_buffer_capacity)
+ _buffer.copy_to(ns, _buffer_length - _buffer_pos, _buffer_pos, 0)
+ _buffer = ns
end
redef fun close
private extern class NativeSocketPollFD `{ struct pollfd * `}
# File descriptor
- fun fd: Int `{ return recv->fd; `}
+ fun fd: Int `{ return self->fd; `}
# List of events to be watched
- fun events: Int `{ return recv->events; `}
+ fun events: Int `{ return self->events; `}
# List of events received by the last poll function
- fun revents: Int `{ return recv->revents; `}
+ fun revents: Int `{ return self->revents; `}
new (pid: Int, events: NativeSocketPollValues) `{
struct pollfd *poll = malloc(sizeof(struct pollfd));
return d;
`}
- fun destroy `{ free(recv); `}
+ fun destroy `{ free(self); `}
- fun close: Int `{ return close(*recv); `}
+ fun close: Int `{ return close(*self); `}
- fun descriptor: Int `{ return *recv; `}
+ fun descriptor: Int `{ return *self; `}
fun gethostbyname(n: String): NativeSocketHostent import String.to_cstring `{ return gethostbyname(String_to_cstring(n)); `}
fun connect(addrIn: NativeSocketAddrIn): Int `{
- return connect(*recv, (struct sockaddr*)addrIn, sizeof(*addrIn));
+ return connect(*self, (struct sockaddr*)addrIn, sizeof(*addrIn));
`}
fun write(buffer: String): Int
import String.to_cstring, String.length `{
- return write(*recv, (char*)String_to_cstring(buffer), String_length(buffer));
+ return write(*self, (char*)String_to_cstring(buffer), String_length(buffer));
`}
# Write `value` as a single byte
fun write_byte(value: Int): Int `{
- return write(*recv, &value, 1);
+ unsigned char byt = (unsigned char)value;
+ return write(*self, &byt, 1);
`}
- fun read: String import NativeString.to_s_with_length `{
+ fun read: String import NativeString.to_s_with_length, NativeString.to_s_with_copy `{
static char c[1024];
- int n = read(*recv, c, 1024);
+ int n = read(*self, c, 1023);
if(n < 0) {
return NativeString_to_s_with_length("",0);
}
- char* ret = malloc(n + 1);
- memcpy(ret, c, n);
- ret[n] = '\0';
- return NativeString_to_s_with_length(ret, n);
+ c[n] = 0;
+ return NativeString_to_s_with_copy(c);
`}
# Sets an option for the socket
#
# Returns `true` on success.
fun setsockopt(level: NativeSocketOptLevels, option_name: NativeSocketOptNames, option_value: Int): Bool `{
- int err = setsockopt(*recv, level, option_name, &option_value, sizeof(int));
+ int err = setsockopt(*self, level, option_name, &option_value, sizeof(int));
if(err != 0){
return 0;
}
return 1;
`}
- fun bind(addrIn: NativeSocketAddrIn): Int `{ return bind(*recv, (struct sockaddr*)addrIn, sizeof(*addrIn)); `}
+ fun bind(addrIn: NativeSocketAddrIn): Int `{ return bind(*self, (struct sockaddr*)addrIn, sizeof(*addrIn)); `}
- fun listen(size: Int): Int `{ return listen(*recv, size); `}
+ fun listen(size: Int): Int `{ return listen(*self, size); `}
# Checks if the buffer is ready for any event specified when creating the pollfd structure
fun socket_poll(filedesc: PollFD, timeout: Int): Array[NativeSocketPollValues]
private fun native_accept(addr_in: NativeSocketAddrIn): NativeSocket `{
socklen_t s = sizeof(struct sockaddr);
- int socket = accept(*recv, (struct sockaddr*)addr_in, &s);
+ int socket = accept(*self, (struct sockaddr*)addr_in, &s);
if (socket == -1) return NULL;
int *ptr = malloc(sizeof(int));
# Set wether this socket is non blocking
fun non_blocking=(value: Bool) `{
- int flags = fcntl(*recv, F_GETFL, 0);
+ int flags = fcntl(*self, F_GETFL, 0);
if (flags == -1) flags = 0;
if (value) {
} else {
return;
}
- fcntl(*recv, F_SETFL, flags);
+ fcntl(*self, F_SETFL, flags);
`}
end
return sai;
`}
- fun address: String import NativeString.to_s `{ return NativeString_to_s((char*)inet_ntoa(recv->sin_addr)); `}
+ fun address: String import NativeString.to_s `{ return NativeString_to_s((char*)inet_ntoa(self->sin_addr)); `}
- fun family: NativeSocketAddressFamilies `{ return recv->sin_family; `}
+ fun family: NativeSocketAddressFamilies `{ return self->sin_family; `}
- fun port: Int `{ return ntohs(recv->sin_port); `}
+ fun port: Int `{ return ntohs(self->sin_port); `}
- fun destroy `{ free(recv); `}
+ fun destroy `{ free(self); `}
end
extern class NativeSocketHostent `{ struct hostent* `}
- private fun native_h_aliases(i: Int): String import NativeString.to_s `{ return NativeString_to_s(recv->h_aliases[i]); `}
+ private fun native_h_aliases(i: Int): String import NativeString.to_s `{ return NativeString_to_s(self->h_aliases[i]); `}
- private fun native_h_aliases_reachable(i: Int): Bool `{ return (recv->h_aliases[i] != NULL); `}
+ private fun native_h_aliases_reachable(i: Int): Bool `{ return (self->h_aliases[i] != NULL); `}
fun h_aliases: Array[String]
do
return d
end
- fun h_addr: String import NativeString.to_s `{ return NativeString_to_s((char*)inet_ntoa(*(struct in_addr*)recv->h_addr)); `}
+ fun h_addr: String import NativeString.to_s `{ return NativeString_to_s((char*)inet_ntoa(*(struct in_addr*)self->h_addr)); `}
- fun h_addrtype: Int `{ return recv->h_addrtype; `}
+ fun h_addrtype: Int `{ return self->h_addrtype; `}
- fun h_length: Int `{ return recv->h_length; `}
+ fun h_length: Int `{ return self->h_length; `}
- fun h_name: String import NativeString.to_s `{ return NativeString_to_s(recv->h_name); `}
+ fun h_name: String import NativeString.to_s `{ return NativeString_to_s(self->h_name); `}
end
extern class NativeTimeval `{ struct timeval* `}
return tv;
`}
- fun seconds: Int `{ return recv->tv_sec; `}
+ fun seconds: Int `{ return self->tv_sec; `}
- fun microseconds: Int `{ return recv->tv_usec; `}
+ fun microseconds: Int `{ return self->tv_usec; `}
- fun destroy `{ free(recv); `}
+ fun destroy `{ free(self); `}
end
extern class NativeSocketSet `{ fd_set* `}
return f;
`}
- fun set(s: NativeSocket) `{ FD_SET(*s, recv); `}
+ fun set(s: NativeSocket) `{ FD_SET(*s, self); `}
- fun is_set(s: NativeSocket): Bool `{ return FD_ISSET(*s, recv); `}
+ fun is_set(s: NativeSocket): Bool `{ return FD_ISSET(*s, self); `}
- fun zero `{ FD_ZERO(recv); `}
+ fun zero `{ FD_ZERO(self); `}
- fun clear(s: NativeSocket) `{ FD_CLR(*s, recv); `}
+ fun clear(s: NativeSocket) `{ FD_CLR(*s, self); `}
- fun destroy `{ free(recv); `}
+ fun destroy `{ free(self); `}
end
class NativeSocketObserver
# Combines two NativeSocketPollValues
private fun +(other: NativeSocketPollValues): NativeSocketPollValues `{
- return recv | other;
+ return self | other;
`}
end
extern class Sqlite3Code `{int`}
new ok `{ return SQLITE_OK; `} # 0 /* Successful result */
- fun is_ok: Bool `{ return recv == SQLITE_OK; `}
+ fun is_ok: Bool `{ return self == SQLITE_OK; `}
# new `{ return SQLITE_ERROR; `} # 1 /* SQL error or missing database */
# new `{ return SQLITE_INTERNAL; `} # 2 /* Internal logic error in SQLite */
# new `{ return SQLITE_WARNING; `} # 28 /* Warnings from sqlite3_log() */
new row `{ return SQLITE_ROW; `} # 100 /* sqlite3_step() has another row ready */
- fun is_row: Bool `{ return recv == SQLITE_ROW; `}
+ fun is_row: Bool `{ return self == SQLITE_ROW; `}
new done `{ return SQLITE_DONE; `} # 101 /* sqlite3_step() has finished executing */
- fun is_done: Bool `{ return recv == SQLITE_DONE; `}
+ fun is_done: Bool `{ return self == SQLITE_DONE; `}
- redef fun to_s: String import NativeString.to_s `{
+ redef fun to_s import NativeString.to_s `{
#if SQLITE_VERSION_NUMBER >= 3007015
- char *err = (char *)sqlite3_errstr(recv);
+ char *err = (char *)sqlite3_errstr(self);
#else
char *err = "sqlite3_errstr supported only by version >= 3.7.15";
#endif
# Evaluate the statement
fun step: Sqlite3Code `{
- return sqlite3_step(recv);
+ return sqlite3_step(self);
`}
fun column_name(i: Int) : String import NativeString.to_s `{
- const char * name = (sqlite3_column_name(recv, i));
+ const char * name = (sqlite3_column_name(self, i));
if(name == NULL){
name = "";
}
# Number of bytes in the blob or string at row `i`
fun column_bytes(i: Int) : Int `{
- return sqlite3_column_bytes(recv, i);
+ return sqlite3_column_bytes(self, i);
`}
fun column_double(i: Int) : Float `{
- return sqlite3_column_double(recv, i);
+ return sqlite3_column_double(self, i);
`}
fun column_int(i: Int) : Int `{
- return sqlite3_column_int(recv, i);
+ return sqlite3_column_int(self, i);
`}
fun column_text(i: Int): NativeString `{
- return (char *)sqlite3_column_text(recv, i);
+ return (char *)sqlite3_column_text(self, i);
`}
# Type of the entry at row `i`
fun column_type(i: Int): DataType `{
- return sqlite3_column_type(recv, i);
+ return sqlite3_column_type(self, i);
`}
- fun column_blob(i: Int): Pointer `{ return (void*)sqlite3_column_blob(recv, i); `}
+ fun column_blob(i: Int): Pointer `{ return (void*)sqlite3_column_blob(self, i); `}
fun column_count: Int `{
- return sqlite3_column_count(recv);
+ return sqlite3_column_count(self);
`}
# Reset this statement to its original state, to be reexecuted
- fun reset: Sqlite3Code `{ return sqlite3_reset(recv); `}
+ fun reset: Sqlite3Code `{ return sqlite3_reset(self); `}
# Delete this statement
- fun finalize: Sqlite3Code `{ return sqlite3_finalize(recv); `}
+ fun finalize: Sqlite3Code `{ return sqlite3_finalize(self); `}
end
# A database connection
# Close this connection
fun close `{
#if SQLITE_VERSION_NUMBER >= 3007014
- sqlite3_close_v2(recv);
+ sqlite3_close_v2(self);
#else
// A program using the older version should not rely on the garbage-collector
// to close its connections. They must be closed manually after the associated
// prepare statements have been finalized.
- sqlite3_close(recv);
+ sqlite3_close(self);
#endif
`}
# Execute a SQL statement
fun exec(sql: String): Sqlite3Code import String.to_cstring `{
- return sqlite3_exec(recv, String_to_cstring(sql), 0, 0, 0);
+ return sqlite3_exec(self, String_to_cstring(sql), 0, 0, 0);
`}
# Prepare a SQL statement
fun prepare(sql: String): nullable NativeStatement import String.to_cstring, NativeStatement.as nullable `{
sqlite3_stmt *stmt;
- int res = sqlite3_prepare_v2(recv, String_to_cstring(sql), -1, &stmt, 0);
+ int res = sqlite3_prepare_v2(self, String_to_cstring(sql), -1, &stmt, 0);
if (res == SQLITE_OK)
return NativeStatement_as_nullable(stmt);
else
`}
fun last_insert_rowid: Int `{
- return sqlite3_last_insert_rowid(recv);
+ return sqlite3_last_insert_rowid(self);
`}
fun error: Sqlite3Code `{
- return sqlite3_errcode(recv);
+ return sqlite3_errcode(self);
`}
end
# Sqlite data types
extern class DataType `{ int `}
- fun is_integer: Bool `{ return recv == SQLITE_INTEGER; `}
- fun is_float: Bool `{ return recv == SQLITE_FLOAT; `}
- fun is_blob: Bool `{ return recv == SQLITE_BLOB; `}
- fun is_null: Bool `{ return recv == SQLITE_NULL; `}
- fun is_text: Bool `{ return recv == SQLITE_TEXT; `}
+ fun is_integer: Bool `{ return self == SQLITE_INTEGER; `}
+ fun is_float: Bool `{ return self == SQLITE_FLOAT; `}
+ fun is_blob: Bool `{ return self == SQLITE_BLOB; `}
+ fun is_null: Bool `{ return self == SQLITE_NULL; `}
+ fun is_text: Bool `{ return self == SQLITE_TEXT; `}
- fun to_i: Int `{ return recv; `}
+ fun to_i: Int `{ return self; `}
end
redef var item: StatementRow is noinit
- redef var is_ok: Bool is noinit
+ redef var is_ok is noinit
# require: `self.statement.is_open`
redef fun next
-# This file is part of NIT ( http://www.nitlanguage.org ).
+# This file is part of NIT (http://www.nitlanguage.org).
#
# Copyright 2014 Julien Pagès <julien.pages@lirmm.fr>
#
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
-# http://www.apache.org/licenses/LICENSE-2.0
+# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
#include <assert.h>
`}
-# Add support of binary operations related
-# to binary level of Integer
-# For compatibility reasons, xor, and, or methods
-# are still in the math.nit module
+# Add support of binary operations related to binary level of Integer
+# For compatibility reasons, xor, and, or methods are still in the `math` module.
redef class Int
- # Sets the i-bit of self to the given value
- # assert 11.setbit(0, 0) == 10
- # assert 10.setbit(0, 1) == 11
+ # Sets the i-bit of self to the given `value`
+ #
+ # assert 11.setbit(0, 0) == 10
+ # assert 10.setbit(0, 1) == 11
fun setbit(index: Int, value: Int): Int `{
assert(index >= 0 && index < 32);
if(value == 1)
- return recv | (1 << index);
+ return self | (1 << index);
else
- return recv & ~(1 << index);
+ return self & ~(1 << index);
`}
- # Returns the i-bit value of self Integer
- # assert 10.getbit(0) == 0
- # assert 10.getbit(3) == 1
+ # Returns the i-bit value of `self`
+ #
+ # assert 10.getbit(0) == 0
+ # assert 10.getbit(3) == 1
fun getbit(index: Int): Int `{
assert(index >= 0 && index < 32);
int op = 1 << index;
-
- if((recv & op) == 0)
+
+ if((self & op) == 0)
return 0;
else
return 1;
`}
# Give a binary representation of self Integer
- fun bits : Array[Int]
+ fun bits: Array[Int]
do
- var bits = new Array[Int].with_capacity(32)
-
+ var bits = new Array[Int].with_capacity(32)
+
for i in [0..32[
do
bits[i] = getbit(i)
return bits
end
- # Returns the number of bits of specified value (0 or 1)
- # in self
- # assert 10.number_bits(1) == 2
- # assert 10.number_bits(0) == 30
+ # Returns the number of bits of specified value (0 or 1) in `self`
+ #
+ # assert 10.number_bits(1) == 2
+ # assert 10.number_bits(0) == 30
fun number_bits(value: Int): Int `{
assert(value == 0 || value == 1);
{
for(i=bound; i>0; i/=2)
{
- if(recv & i)
+ if(self & i)
count++;
}
}
{
for(i=bound; i>0; i/=2)
{
- if(!(recv & i))
+ if(!(self & i))
count++;
}
}
return count;
`}
- # Returns the position of the highest bit
- # set to 1 in self (the rightest bit is at position 0)
- # assert 10.highest_bit == 3
- # assert 1.highest_bit == 0
- fun highest_bit: Int `{
+ # Returns the position of the highest bit set to 1 in `self`
+ #
+ # The rightmost bit is at position 0.
+ #
+ # assert 10.highest_bit == 3
+ # assert 1.highest_bit == 0
+ fun highest_bit: Int `{
long int msb = 1L << 31;
int pos = 31;
-
- while(msb > 0 && !(recv & msb))
+
+ while(msb > 0 && !(self & msb))
{
msb /= 2;
pos--;
}
-
+
return pos;
`}
end
private var items: NativeString
# Number of bytes in the array
- redef var length: Int
+ redef var length
# Capacity of the array
private var capacity: Int
# var b = new Bytes.empty
# b.add 101
# assert b[0] == 101
- redef fun [](i: Int): Int do
+ redef fun [](i) do
assert i >= 0
assert i < length
return items[i].ascii
# var b = new Bytes.with_capacity(1)
# b[0] = 101
# assert b.to_s == "e"
- redef fun []=(i: Int, v: Int) do
+ redef fun []=(i, v) do
if persisted then regen
assert i >= 0
assert i <= length
# var b = new Bytes.empty
# b.add 101
# assert b.to_s == "e"
- redef fun add(c: Int) do
+ redef fun add(c) do
if persisted then regen
if length >= capacity then
enlarge(length)
# var b = new Bytes.empty
# b.append([104, 101, 108, 108, 111])
# assert b.to_s == "hello"
- redef fun append(arr: Collection[Int]) do
+ redef fun append(arr) do
if arr isa Bytes then
append_ns(arr.items, arr.length)
else
var tgt: NativeString
- redef var index: Int
+ redef var index
var max: Int
redef fun next do is_ok = false
- redef var is_ok: Bool = true
+ redef var is_ok = true
var container: Container[E]
end
private class CoupleMapIterator[K, V]
super MapIterator[K, V]
redef fun item do return _iter.item.second
-
+
#redef fun item=(e) do _iter.item.second = e
redef fun key do return _iter.item.first
#
# This file is free software, which comes along with NIT. This software 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
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. You can modify it is you want, provided this header
# is kept unaltered, and a notification of the changes is added.
# You are allowed to redistribute it and sell it, alone or is a part of
redef fun last_index_of(item) do return last_index_of_from(item, length-1)
- redef fun index_of_from(item, pos)
- do
+ redef fun index_of_from(item, pos) do
var i = pos
var len = length
while i < len do
return -1
end
- redef fun last_index_of_from(item, pos)
- do
+ redef fun last_index_of_from(item, pos) do
var i = pos
while i >= 0 do
if self[i] == item then
self[0] = item
end
- redef fun insert(item: E, pos: Int)
- do
+ redef fun insert(item, pos) do
enlarge(length + 1)
copy_to(pos, length-pos, self, pos + 1)
self[pos] = item
push(e)
return
end
- var nnode = new ListNode[E](e)
- var next = node.next
- if next == null then
- _tail = nnode
- else
- next.prev = nnode
- end
- nnode.prev = node
- nnode.next = next
- node.next = nnode
+ insert_before(e, node)
end
# Append `l` to `self` but clear `l`.
#
# This file is free software, which comes along with NIT. This software 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
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. You can modify it is you want, provided this header
# is kept unaltered, and a notification of the changes is added.
# You are allowed to redistribute it and sell it, alone or is a part of
class Range[E: Discrete]
super Collection[E]
- redef var first: E
+ redef var first
# Get the last element.
var last: E
end
redef class Int
- # Returns the range from 0 to `self-1`, is used to do:
+ # Returns the range from 0 to `self-1`.
#
- # var s = new Array[String]
- # for i in 3.times do s.add "cool"
- # assert s.join(" ") == "cool cool cool"
+ # assert 3.times == [0..3[
+ # assert 10.times == [0..10[
+ # assert ((-1).times).is_empty
#
- # s.clear
- # for i in 10.times do s.add(i.to_s)
- # assert s.to_s == "0123456789"
+ # This can be usefull for loops:
+ #
+ # var s = new Array[String]
+ # for i in 3.times do s.add "cool"
+ # assert s.join(" ") == "cool cool cool"
fun times: Range[Int] do return [0 .. self[
end
# s.add(1)
# assert s.has(1)
# assert not s.has(2)
- redef fun has(e)
- do
+ redef fun has(e) do
return nodes.has_key(e)
end
# Initially it is in its own disjoint subset
#
# ENSURE: `has(e)`
- redef fun add(e:E)
- do
+ redef fun add(e) do
if nodes.has_key(e) then return
var ne = new DisjointSetNode
nodes[e] = ne
return
end
end_reached = false
- _buffer_pos = 0
- _buffer.clear
+ buffer_reset
end
redef fun close
do
super
- _buffer.clear
+ buffer_reset
end_reached = true
end
redef fun fill_buffer
do
- var nb = _file.io_read(_buffer.items, _buffer.capacity)
+ var nb = _file.io_read(_buffer, _buffer_capacity)
if nb <= 0 then
end_reached = true
nb = 0
end
- _buffer.length = nb
+ _buffer_length = nb
_buffer_pos = 0
end
# End of file?
- redef var end_reached: Bool = false
+ redef var end_reached = false
# Open the file at `path` for reading.
#
super FileStream
super Writer
+ redef fun write_bytes(s) do
+ if last_error != null then return
+ if not _is_writable then
+ last_error = new IOError("cannot write to non-writable stream")
+ return
+ end
+ write_native(s.items, s.length)
+ end
+
redef fun write(s)
do
if last_error != null then return
if not _is_writable then
- last_error = new IOError("Cannot write to non-writable stream")
+ last_error = new IOError("cannot write to non-writable stream")
return
end
- if s isa FlatText then
- write_native(s.to_cstring, s.length)
- else
- for i in s.substrings do write_native(i.to_cstring, i.length)
- end
+ for i in s.substrings do write_native(i.to_cstring, i.length)
end
redef fun write_byte(value)
prepare_buffer(1)
end
- redef fun poll_in: Bool is extern "file_stdin_poll_in"
+ redef fun poll_in is extern "file_stdin_poll_in"
end
# Standard output stream.
# ~~~
#
# See `Reader::read_all` for details.
- fun read_all: String
+ fun read_all: String do return read_all_bytes.to_s
+
+ fun read_all_bytes: Bytes
do
var s = open_ro
- var res = s.read_all
+ var res = s.read_all_bytes
s.close
return res
end
struct stat* stat_element;
int res;
stat_element = malloc(sizeof(struct stat));
- res = lstat(recv, stat_element);
+ res = lstat(self, stat_element);
if (res == -1) return NULL;
return stat_element;
`}
private fun file_mkdir: Bool is extern "string_NativeString_NativeString_file_mkdir_0"
- private fun rmdir: Bool `{ return !rmdir(recv); `}
+ private fun rmdir: Bool `{ return !rmdir(self); `}
private fun file_delete: Bool is extern "string_NativeString_NativeString_file_delete_0"
private fun file_chdir: Bool is extern "string_NativeString_NativeString_file_chdir_0"
private fun file_realpath: NativeString is extern "file_NativeString_realpath"
fun size: Int is extern "file_FileStat_FileStat_size_0"
# Returns true if it is a regular file (not a device file, pipe, sockect, ...)
- fun is_reg: Bool `{ return S_ISREG(recv->st_mode); `}
+ fun is_reg: Bool `{ return S_ISREG(self->st_mode); `}
# Returns true if it is a directory
- fun is_dir: Bool `{ return S_ISDIR(recv->st_mode); `}
+ fun is_dir: Bool `{ return S_ISDIR(self->st_mode); `}
# Returns true if it is a character device
- fun is_chr: Bool `{ return S_ISCHR(recv->st_mode); `}
+ fun is_chr: Bool `{ return S_ISCHR(self->st_mode); `}
# Returns true if it is a block device
- fun is_blk: Bool `{ return S_ISBLK(recv->st_mode); `}
+ fun is_blk: Bool `{ return S_ISBLK(self->st_mode); `}
# Returns true if the type is fifo
- fun is_fifo: Bool `{ return S_ISFIFO(recv->st_mode); `}
+ fun is_fifo: Bool `{ return S_ISFIFO(self->st_mode); `}
# Returns true if the type is a link
- fun is_lnk: Bool `{ return S_ISLNK(recv->st_mode); `}
+ fun is_lnk: Bool `{ return S_ISLNK(self->st_mode); `}
# Returns true if the type is a socket
- fun is_sock: Bool `{ return S_ISSOCK(recv->st_mode); `}
+ fun is_sock: Bool `{ return S_ISSOCK(self->st_mode); `}
end
# Instance of this class are standard FILE * pointers
fun io_write(buf: NativeString, len: Int): Int is extern "file_NativeFile_NativeFile_io_write_2"
fun write_byte(value: Int): Int `{
unsigned char b = (unsigned char)value;
- return fwrite(&b, 1, 1, recv);
+ return fwrite(&b, 1, 1, self);
`}
fun io_close: Int is extern "file_NativeFile_NativeFile_io_close_0"
fun file_stat: NativeFileStat is extern "file_NativeFile_NativeFile_file_stat_0"
- fun fileno: Int `{ return fileno(recv); `}
+ fun fileno: Int `{ return fileno(self); `}
# Flushes the buffer, forcing the write operation
fun flush: Int is extern "fflush"
# Used to specify how the buffering will be handled for the current stream.
new opendir(path: NativeString) `{ return opendir(path); `}
# Close a directory
- fun closedir `{ closedir(recv); `}
+ fun closedir `{ closedir(self); `}
# Read the next directory entry
fun readdir: NativeString `{
struct dirent *de;
- de = readdir(recv);
+ de = readdir(self);
if (!de) return NULL;
return de->d_name;
`}
#
# This file is free software, which comes along with NIT. This software 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
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. You can modify it is you want, provided this header
# is kept unaltered, and a notification of the changes is added.
# You are allowed to redistribute it and sell it, alone or is a part of
type OTHER: Comparable
# Is `self` lesser than `other`?
- fun <(other: OTHER): Bool is abstract
+ fun <(other: OTHER): Bool is abstract
# not `other` < `self`
# Note, the implementation must ensure that: `(x<=y) == (x<y or x==y)`
redef fun !=(i) is intern
redef fun output is intern
- redef fun <=(i): Bool is intern
- redef fun <(i): Bool is intern
- redef fun >=(i): Bool is intern
- redef fun >(i): Bool is intern
+ redef fun <=(i) is intern
+ redef fun <(i) is intern
+ redef fun >=(i) is intern
+ redef fun >(i) is intern
redef fun +(i) is intern
redef fun - is intern
redef fun is_between(c, d)
do
- if self < c or d < self then
+ if self < c or d < self then
return false
- else
+ else
return true
end
end
# count digits
while n > 0 do
d += 1
- n = n / b # euclidian division /
+ n = n / b # euclidian division /
end
return d
end
# Returns the square root of `self`
#
# assert 16.sqrt == 4
- fun sqrt: Int `{ return sqrt(recv); `}
+ fun sqrt: Int `{ return sqrt(self); `}
# Returns the greatest common divisor of `self` and `o`
#
# assert 12.0.abs == 12.0
# assert (-34.56).abs == 34.56
# assert -34.56.abs == -34.56
- fun abs: Float `{ return fabs(recv); `}
+ fun abs: Float `{ return fabs(self); `}
# Returns `self` raised at `e` power.
#
# assert 1.9.ceil == 2.0
# assert 2.0.ceil == 2.0
# assert (-1.5).ceil == -1.0
- fun ceil: Float `{ return ceil(recv); `}
+ fun ceil: Float `{ return ceil(self); `}
# assert 1.1.floor == 1.0
# assert 1.9.floor == 1.0
# assert 2.0.floor == 2.0
# assert (-1.5).floor == -2.0
- fun floor: Float `{ return floor(recv); `}
+ fun floor: Float `{ return floor(self); `}
# Rounds the value of a float to its nearest integer value
#
new from_name(name: String) import String.to_cstring `{ return getpwnam( String_to_cstring(name) ); `}
# Username
- fun name: String import NativeString.to_s `{ return NativeString_to_s(recv->pw_name); `}
+ fun name: String import NativeString.to_s `{ return NativeString_to_s(self->pw_name); `}
# User password
- fun passwd: String import NativeString.to_s `{ return NativeString_to_s(recv->pw_passwd); `}
+ fun passwd: String import NativeString.to_s `{ return NativeString_to_s(self->pw_passwd); `}
# User ID
- fun uid: Int `{ return recv->pw_uid; `}
+ fun uid: Int `{ return self->pw_uid; `}
# Group ID
- fun gid: Int `{ return recv->pw_gid; `}
+ fun gid: Int `{ return self->pw_gid; `}
# Home directory
- fun dir: String import NativeString.to_s `{ return NativeString_to_s(recv->pw_dir); `}
+ fun dir: String import NativeString.to_s `{ return NativeString_to_s(self->pw_dir); `}
# Shell program
- fun shell: String import NativeString.to_s `{ return NativeString_to_s(recv->pw_shell); `}
+ fun shell: String import NativeString.to_s `{ return NativeString_to_s(self->pw_shell); `}
end
# Information on a user group
new from_name(name: String) import String.to_cstring `{ return getgrnam( String_to_cstring(name) ); `}
# Name of this ground
- fun name: String import NativeString.to_s `{ return NativeString_to_s(recv->gr_name); `}
+ fun name: String import NativeString.to_s `{ return NativeString_to_s(self->gr_name); `}
# Encrypted password of this group
- fun passwd: String import NativeString.to_s `{ return NativeString_to_s(recv->gr_passwd); `}
+ fun passwd: String import NativeString.to_s `{ return NativeString_to_s(self->gr_passwd); `}
# Id of this group
- fun gid: Int `{ return recv->gr_gid; `}
+ fun gid: Int `{ return self->gr_gid; `}
# List of the members of the group
fun mem: Array[String] import Array[String], Array[String].add, NativeString.to_s `{
int m;
Array_of_String ret;
- mem = recv->gr_mem;
+ mem = self->gr_mem;
ret = new_Array_of_String();
for (m = 0; mem[m] != NULL; m++)
# Compile the regular expression `regex` into a form that is suitable for subsequent `regexec` searches
fun regcomp(regex: NativeString, cflags: Int): Int `{
- return regcomp(recv, regex, cflags);
+ return regcomp(self, regex, cflags);
`}
# Match `string` against the precompiled pattern buffer of `self`, locating matches
# `nmatch` and `pmatch` are used to provide information regarding the location of any matches.
# `eflags` may be the bitwise-or of one or both of `flag_notbol` and `flag_noteol`.
fun regexec(string: NativeString, nmatch: Int, pmatch: NativeMatchArray, eflags: Int): Int `{
- return regexec(recv, string, nmatch, pmatch, eflags);
+ return regexec(self, string, nmatch, pmatch, eflags);
`}
# Match `string` against the precompiled pattern buffer of `self`, do not locate matches
#
# `eflags` may be the bitwise-or of one or both of `flag_notbol` and `flag_noteol`.
fun regexec_match_only(string: NativeString, eflags: Int): Int `{
- return regexec(recv, string, 0, NULL, eflags);
+ return regexec(self, string, 0, NULL, eflags);
`}
# Free the memory allocated to the pattern buffer by the compiling process
#
# Does not free the memory holding `self`, use `free` for this purpose.
- fun regfree `{ regfree(recv); `}
+ fun regfree `{ regfree(self); `}
# Turn the error codes that can be returned by both `regcomp` and `regexec` into error message strings
fun regerror(errcode: Int): NativeString `{
- size_t len = regerror(errcode, recv, NULL, 0);
+ size_t len = regerror(errcode, self, NULL, 0);
char *message = malloc(len);
- regerror(errcode, recv, message, len);
+ regerror(errcode, self, message, len);
return message;
`}
# Number of parenthetical subexpressions in this compiled regular expression
- fun re_nsub: Int `{ return recv->re_nsub; `}
+ fun re_nsub: Int `{ return self->re_nsub; `}
end
# Flags for `NativeRegex::regcomp`
private fun error_espace: Int `{ return REG_ESPACE; `}
redef universal Int
- private fun is_nomatch: Bool `{ return recv == REG_NOMATCH; `}
+ private fun is_nomatch: Bool `{ return self == REG_NOMATCH; `}
end
# An array of `regmatch_t` or a pointer to one
new malloc(length: Int) `{ return malloc(length * sizeof(regmatch_t)); `}
# The offset in string of the beginning of a substring
- fun rm_so: Int `{ return recv->rm_so; `}
+ fun rm_so: Int `{ return self->rm_so; `}
# The offset in string of the end of the substring
- fun rm_eo: Int `{ return recv->rm_eo; `}
+ fun rm_eo: Int `{ return self->rm_eo; `}
# Get a pointer to the element at `index`, can also be used as a subarray
- fun [](index: Int): NativeMatchArray `{ return recv + index; `}
+ fun [](index: Int): NativeMatchArray `{ return self + index; `}
end
redef extern class NativeString
- private fun substring_from(index: Int): NativeString `{ return recv + index; `}
+ private fun substring_from(index: Int): NativeString `{ return self + index; `}
end
redef class Text
private class Concat
super RopeString
- redef var length: Int is noinit
+ redef var length is noinit
redef fun substrings do return new RopeSubstrings(self)
end
redef fun copy_to_native(dest, n, src_offset, dest_offset) do
- var remlen = n
var subs = new RopeSubstrings.from(self, src_offset)
var st = src_offset - subs.pos
var off = dest_offset
# Maximum position iterable.
var maxpos: Int
- redef var index: Int
+ redef var index
# Init the iterator from a RopeBuffer.
init(t: RopeBuffer) is old_style_init do
# Current position in `ns`.
var pns: Int
- redef var index: Int
+ redef var index
# Init the iterator from a RopeBuffer.
init(tgt: RopeBuffer) is old_style_init do
intrude import ropes
import error
+intrude import bytes
in "C" `{
#include <unistd.h>
# Reads a byte. Returns `null` on EOF or timeout
fun read_byte: nullable Int is abstract
+ # Reads a String of at most `i` length
+ fun read(i: Int): String do return read_bytes(i).to_s
+
# Read at most i bytes
- fun read(i: Int): String
+ fun read_bytes(i: Int): Bytes
do
- if last_error != null then return ""
- var s = new FlatBuffer.with_capacity(i)
+ if last_error != null then return new Bytes.empty
+ var s = new NativeString(i)
+ var buf = new Bytes(s, 0, 0)
while i > 0 and not eof do
- var c = read_char
+ var c = read_byte
if c != null then
- s.add(c)
+ buf.add c
i -= 1
end
end
- return s.to_s
+ return buf
end
# Read a string until the end of the line.
# Read all the stream until the eof.
#
- # The content of the file is returned verbatim.
+ # The content of the file is returned as a String.
#
# ~~~
# var txt = "Hello\n\nWorld\n"
# var i = new StringReader(txt)
# assert i.read_all == txt
# ~~~
- fun read_all: String
+ fun read_all: String do return read_all_bytes.to_s
+
+ # Read all the stream until the eof.
+ #
+ # The content of the file is returned verbatim.
+ fun read_all_bytes: Bytes
do
- if last_error != null then return ""
- var s = new FlatBuffer
+ if last_error != null then return new Bytes.empty
+ var s = new Bytes.empty
while not eof do
- var c = read_char
+ var c = read_byte
if c != null then s.add(c)
end
- return s.to_s
+ return s
end
# Read a string until the end of the line and append it to `s`.
# A `Stream` that can be written to
abstract class Writer
super Stream
+
+ # Writes bytes from `s`
+ fun write_bytes(s: Bytes) is abstract
+
# write a string
fun write(s: Text) is abstract
# Like `write_to` but return a new String (may be quite large)
#
- # This funtionnality is anectodical, since the point
+ # This funtionality is anectodical, since the point
# of streamable object to to be efficienlty written to a
# stream without having to allocate and concatenate strings
fun write_to_string: String
return c
end
- # Peeks up to `n` bytes in the buffer, returns an empty string on EOF
+ fun buffer_reset do
+ _buffer_length = 0
+ _buffer_pos = 0
+ end
+
+ # Peeks up to `n` bytes in the buffer
#
# The operation does not consume the buffer
#
# ~~~nitish
- # var x = new FileReader("File.txt")
- # assert x.peek(5) == x.read(5)
+ # var x = new FileReader.open("File.txt")
+ # assert x.peek(5) == x.read(5)
# ~~~
- fun peek(i: Int): String do
- if eof then return ""
- var b = new FlatBuffer.with_capacity(i)
- while i > 0 and not eof do
- b.add _buffer[_buffer_pos]
- _buffer_pos += 1
- i -= 1
+ fun peek(i: Int): Bytes do
+ if eof then return new Bytes.empty
+ var remsp = _buffer_length - _buffer_pos
+ if i <= remsp then
+ var bf = new Bytes.with_capacity(i)
+ bf.append_ns_from(_buffer, i, _buffer_pos)
+ return bf
end
- var nbuflen = b.length + (_buffer.length - _buffer_pos)
- var nbuf = new FlatBuffer.with_capacity(nbuflen)
- nbuf.append(b)
- while _buffer_pos < _buffer.length do
- nbuf.add(_buffer[_buffer_pos])
- _buffer_pos += 1
+ var bf = new Bytes.with_capacity(i)
+ bf.append_ns_from(_buffer, remsp, _buffer_pos)
+ _buffer_pos = _buffer_length
+ read_intern(i - bf.length, bf)
+ remsp = _buffer_length - _buffer_pos
+ var full_len = bf.length + remsp
+ if full_len > _buffer_capacity then
+ var c = _buffer_capacity
+ while c < full_len do c = c * 2 + 2
+ _buffer_capacity = c
end
+ var nns = new NativeString(_buffer_capacity)
+ bf.items.copy_to(nns, bf.length, 0, 0)
+ _buffer.copy_to(nns, remsp, _buffer_pos, bf.length)
+ _buffer = nns
_buffer_pos = 0
- _buffer = nbuf
- return b.to_s
+ _buffer_length = full_len
+ return bf
end
- redef fun read(i)
+ redef fun read_bytes(i)
do
- if last_error != null then return ""
- if eof then return ""
+ if last_error != null then return new Bytes.empty
+ var buf = new Bytes.with_capacity(i)
+ read_intern(i, buf)
+ return buf
+ end
+
+ # Fills `buf` with at most `i` bytes read from `self`
+ private fun read_intern(i: Int, buf: Bytes): Int do
+ if eof then return 0
var p = _buffer_pos
- var bufsp = _buffer.length - p
+ var bufsp = _buffer_length - p
if bufsp >= i then
_buffer_pos += i
- return _buffer.substring(p, i).to_s
+ buf.append_ns_from(_buffer, i, p)
+ return i
end
- _buffer_pos = _buffer.length
- var readln = _buffer.length - p
- var s = _buffer.substring(p, readln).to_s
- fill_buffer
- return s + read(i - readln)
+ _buffer_pos = _buffer_length
+ var readln = _buffer_length - p
+ buf.append_ns_from(_buffer, readln, p)
+ var rd = read_intern(i - readln, buf)
+ return rd + readln
end
- redef fun read_all
+ redef fun read_all_bytes
do
- if last_error != null then return ""
- var s = new FlatBuffer
+ if last_error != null then return new Bytes.empty
+ var s = new Bytes.with_capacity(10)
while not eof do
var j = _buffer_pos
- var k = _buffer.length
+ var k = _buffer_length
while j < k do
- s.add(_buffer[j])
+ s.add(_buffer[j].ascii)
j += 1
end
_buffer_pos = j
fill_buffer
end
- return s.to_s
+ return s
end
redef fun append_line_to(s)
loop
# First phase: look for a '\n'
var i = _buffer_pos
- while i < _buffer.length and _buffer[i] != '\n' do i += 1
+ while i < _buffer_length and _buffer[i] != '\n' do
+ i += 1
+ end
var eol
- if i < _buffer.length then
+ if i < _buffer_length then
assert _buffer[i] == '\n'
i += 1
eol = true
redef fun eof
do
- if _buffer_pos < _buffer.length then return false
+ if _buffer_pos < _buffer_length then return false
if end_reached then return true
fill_buffer
- return _buffer_pos >= _buffer.length and end_reached
+ return _buffer_pos >= _buffer_length and end_reached
end
# The buffer
- private var buffer: nullable FlatBuffer = null
+ private var buffer: NativeString = new NativeString(0)
# The current position in the buffer
- private var buffer_pos: Int = 0
+ private var buffer_pos = 0
+
+ # Length of the current buffer (i.e. nuber of bytes in the buffer)
+ private var buffer_length = 0
+
+ # Capacity of the buffer
+ private var buffer_capacity = 0
# Fill the buffer
protected fun fill_buffer is abstract
- # Is the last fill_buffer reach the end
+ # Has the last fill_buffer reached the end
protected fun end_reached: Bool is abstract
# Allocate a `_buffer` for a given `capacity`.
protected fun prepare_buffer(capacity: Int)
do
- _buffer = new FlatBuffer.with_capacity(capacity)
+ _buffer = new NativeString(capacity)
_buffer_pos = 0 # need to read
+ _buffer_length = 0
+ _buffer_capacity = capacity
end
end
private var content = new Array[String]
redef fun to_s do return content.to_s
redef fun is_writable do return not closed
+
+ redef fun write_bytes(b) do
+ content.add(b.to_s)
+ end
+
redef fun write(str)
do
assert not closed
source = ""
end
- redef fun read_all do
- var c = cursor
- cursor = source.length
- if c == 0 then return source
- return source.substring_from(c)
+ redef fun read_all_bytes do
+ var nslen = source.length - cursor
+ var nns = new NativeString(nslen)
+ source.copy_to_native(nns, nslen, cursor, 0)
+ return new Bytes(nns, nslen, nslen)
end
redef fun eof do return cursor >= source.length
# assert "ff".to_hex == 255
fun to_hex: Int do return a_to(16)
+ # If `self` contains only digits <= '7', return the corresponding integer.
+ #
+ # assert "714".to_oct == 460
+ fun to_oct: Int do return a_to(8)
+
+ # If `self` contains only '0' et '1', return the corresponding integer.
+ #
+ # assert "101101".to_bin == 45
+ fun to_bin: Int do return a_to(2)
+
# If `self` contains only digits and letters, return the corresponding integer in a given base
#
# assert "120".a_to(3) == 15
#
# REQUIRE: `n` must be large enough to contain `len` bytes
#
- # var ns = new NativeString(8)
- # "Text is String".copy_to_native(ns, 8, 2, 0)
+ # var ns = new NativeString(8)
+ # "Text is String".copy_to_native(ns, 8, 2, 0)
# assert ns.to_s_with_length(8) == "xt is St"
#
fun copy_to_native(dest: NativeString, n, src_offset, dest_offset: Int) do
# copy locally the char* as Nit Strings are immutable.
private fun fast_cstring: NativeString is abstract
- redef var length: Int = 0
+ redef var length = 0
redef fun output
do
# Indes in _items of the last item of the string
private var index_to: Int is noinit
- redef var chars: SequenceRead[Char] = new FlatStringCharView(self) is lazy
+ redef var chars = new FlatStringCharView(self) is lazy
redef fun [](index)
do
index_to = to
end
- redef fun to_cstring: NativeString
- do
+ redef fun to_cstring do
if real_items != null then
return real_items.as(not null)
else
capacity = c
end
- redef fun to_s: String
- do
+ redef fun to_s do
written = true
if length == 0 then items = new NativeString(1)
return new FlatString.with_infos(items, length, 0, length - 1)
new from_i(i: Int) `{ return i; `}
# Update current time.
- fun update `{ time(&recv); `}
+ fun update `{ time(&self); `}
# Convert `self` to a human readable String.
fun ctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( ctime(&recv) );
+ return NativeString_to_s_with_copy( ctime(&self) );
`}
# Difference in secondes from start (self if the end time)
- fun difftime(start: TimeT): Float `{ return difftime(recv, start); `}
+ fun difftime(start: TimeT): Float `{ return difftime(self, start); `}
redef fun to_s do return ctime.replace("\n", "")
# Convert self to Int (expressed as seconds since epoch).
- fun to_i: Int `{ return (int)recv; `}
+ fun to_i: Int `{ return (int)self; `}
end
# Time structure
`}
# Convert `self` as a TimeT.
- fun to_timet: TimeT `{ return mktime(recv); `}
+ fun to_timet: TimeT `{ return mktime(self); `}
# Seconds after the minute.
- fun sec: Int `{ return recv->tm_sec; `}
+ fun sec: Int `{ return self->tm_sec; `}
# Minutes after the hour.
- fun min: Int `{ return recv->tm_min; `}
+ fun min: Int `{ return self->tm_min; `}
# hours since midnight.
- fun hour: Int `{ return recv->tm_hour; `}
+ fun hour: Int `{ return self->tm_hour; `}
# Day of the month.
- fun mday: Int `{ return recv->tm_mday; `}
+ fun mday: Int `{ return self->tm_mday; `}
# Months since January.
- fun mon: Int `{ return recv->tm_mon; `}
+ fun mon: Int `{ return self->tm_mon; `}
# Years since 1900.
- fun year: Int `{ return recv->tm_year; `}
+ fun year: Int `{ return self->tm_year; `}
# Days since Sunday.
- fun wday: Int `{ return recv->tm_wday; `}
+ fun wday: Int `{ return self->tm_wday; `}
# Days since January 1st.
- fun yday: Int `{ return recv->tm_yday; `}
+ fun yday: Int `{ return self->tm_yday; `}
# Is `self` in Daylight Saving Time.
- fun is_dst: Bool `{ return recv->tm_isdst; `}
+ fun is_dst: Bool `{ return self->tm_isdst; `}
# Convert `self` to a human readable String.
fun asctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( asctime(recv) );
+ return NativeString_to_s_with_copy( asctime(self) );
`}
# Convert `self` to a human readable String corresponding to `format`.
buf = (char*)malloc(100);
c_format = String_to_cstring(format);
- res = strftime(buf, 100, c_format, recv);
+ res = strftime(buf, 100, c_format, self);
String s = NativeString_to_s_with_copy(buf);
free(buf);
return s;
# 4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
# ~~~
private fun len: Int `{
- char* ns = recv->ns;
- int pos = recv->pos;
+ char* ns = self->ns;
+ int pos = self->pos;
char nspos = ns[pos];
if((nspos & 0x80) == 0x00){ return 1;}
if((nspos & 0xE0) == 0xC0){ return 2;}
# Position in containing NativeString
private fun pos: Int `{
- return recv->pos;
+ return self->pos;
`}
- private fun pos=(p: Int) `{recv->pos = p;`}
+ private fun pos=(p: Int) `{self->pos = p;`}
# C char* wrapping the char
fun ns: NativeString `{
- return recv->ns;
+ return self->ns;
`}
# Returns the Unicode code point representing the character
#
# Note : A unicode character might not be a visible glyph, but it will be used to determine canonical equivalence
fun code_point: Int import UTF8Char.len `{
- switch(UTF8Char_len(recv)){
+ switch(UTF8Char_len(self)){
case 1:
- return (long)(0x7F & (unsigned char)recv->ns[recv->pos]);
+ return (long)(0x7F & (unsigned char)self->ns[self->pos]);
case 2:
- return 0 | ((0x1F & (unsigned char)recv->ns[recv->pos]) << 6) | (0x3F & (unsigned char)recv->ns[recv->pos+1]);
+ return 0 | ((0x1F & (unsigned char)self->ns[self->pos]) << 6) | (0x3F & (unsigned char)self->ns[self->pos+1]);
case 3:
- return 0 | ((0x0F & (unsigned char)recv->ns[recv->pos]) << 12) |
- ((0x3F & (unsigned char)recv->ns[recv->pos+1]) << 6) |
- (0x3F & (unsigned char)recv->ns[recv->pos+2]);
+ return 0 | ((0x0F & (unsigned char)self->ns[self->pos]) << 12) |
+ ((0x3F & (unsigned char)self->ns[self->pos+1]) << 6) |
+ (0x3F & (unsigned char)self->ns[self->pos+2]);
case 4:
- return 0 | ((0x07 & (unsigned char)recv->ns[recv->pos]) << 18) |
- ((0x3F & (unsigned char)recv->ns[recv->pos+1]) << 12) |
- ((0x3F & (unsigned char)recv->ns[recv->pos+2]) << 6) |
- (0x3F & (unsigned char)recv->ns[recv->pos+3]);
+ return 0 | ((0x07 & (unsigned char)self->ns[self->pos]) << 18) |
+ ((0x3F & (unsigned char)self->ns[self->pos+1]) << 12) |
+ ((0x3F & (unsigned char)self->ns[self->pos+2]) << 6) |
+ (0x3F & (unsigned char)self->ns[self->pos+3]);
}
`}
# NOTE : Works only on ASCII chars
# TODO : Support unicode for to_upper
fun to_upper: UTF8Char import UTF8Char.code_point `{
- int cp = UTF8Char_code_point(recv);
- if(cp < 97 || cp > 122){ return recv; }
+ int cp = UTF8Char_code_point(self);
+ if(cp < 97 || cp > 122){ return self; }
char* ns = malloc(2);
ns[1] = '\0';
- char c = recv->ns[recv->pos];
+ char c = self->ns[self->pos];
ns[0] = c - 32;
UTF8Char* ret = malloc(sizeof(UTF8Char));
ret->ns = ns;
# NOTE : Works only on ASCII chars
# TODO : Support unicode for to_upper
fun to_lower: UTF8Char import UTF8Char.code_point `{
- int cp = UTF8Char_code_point(recv);
- if(cp < 65 || cp > 90){ return recv; }
+ int cp = UTF8Char_code_point(self);
+ if(cp < 65 || cp > 90){ return self; }
char* ns = malloc(2);
ns[1] = '\0';
- char c = recv->ns[recv->pos];
+ char c = self->ns[self->pos];
ns[0] = c + 32;
UTF8Char* ret = malloc(sizeof(UTF8Char));
ret->ns = ns;
end
redef fun output import UTF8Char.code_point `{
- switch(UTF8Char_len(recv)){
+ switch(UTF8Char_len(self)){
case 1:
- printf("%c", recv->ns[recv->pos]);
+ printf("%c", self->ns[self->pos]);
break;
case 2:
- printf("%c%c", recv->ns[recv->pos], recv->ns[recv->pos + 1]);
+ printf("%c%c", self->ns[self->pos], self->ns[self->pos + 1]);
break;
case 3:
- printf("%c%c%c", recv->ns[recv->pos], recv->ns[recv->pos + 1], recv->ns[recv->pos + 2]);
+ printf("%c%c%c", self->ns[self->pos], self->ns[self->pos + 1], self->ns[self->pos + 2]);
break;
case 4:
- printf("%c%c%c%c", recv->ns[recv->pos], recv->ns[recv->pos + 1], recv->ns[recv->pos + 2], recv->ns[recv->pos + 3]);
+ printf("%c%c%c%c", self->ns[self->pos], self->ns[self->pos + 1], self->ns[self->pos + 2], self->ns[self->pos + 3]);
break;
}
`}
redef fun to_s import NativeString.to_s_with_length `{
- int len = utf8___UTF8Char_len___impl(recv);
+ int len = utf8___UTF8Char_len___impl(self);
char* r = malloc(len + 1);
r[len] = '\0';
- char* src = (recv->ns + recv->pos);
+ char* src = (self->ns + self->pos);
memcpy(r, src, len);
return NativeString_to_s_with_length(r, len);
`}
new(size: Int) `{ return malloc(size*sizeof(UTF8Char)); `}
# Sets the character at `index` as `item`
- fun []=(index: Int, item: UTF8Char) `{ recv[index] = *item; `}
+ fun []=(index: Int, item: UTF8Char) `{ self[index] = *item; `}
# Gets the character at position `id`
- fun [](id: Int): UTF8Char `{ return &recv[id]; `}
+ fun [](id: Int): UTF8Char `{ return &self[id]; `}
# Copies a part of self starting at index `my_from` of length `length` into `other`, starting at `its_from`
fun copy_to(other: StringIndex, my_from: Int, its_from: Int, length: Int)`{
- UTF8Char* myfrom = recv + my_from*(sizeof(UTF8Char));
+ UTF8Char* myfrom = self + my_from*(sizeof(UTF8Char));
UTF8Char* itsfrom = other + its_from*(sizeof(UTF8Char));
memcpy(itsfrom, myfrom, length);
`}
while(pos < length){
UTF8Char* curr = &index[index_pos];
curr->pos = pos;
- curr->ns = recv;
+ curr->ns = self;
pos += UTF8Char_len(curr);
index_pos ++;
}
return to_s_with_length(len)
end
- redef fun to_s_with_length(len: Int): FlatString
+ redef fun to_s_with_length(len)
do
var real_len = new Container[Int](0)
var x = make_index(len, real_len)
# 4 | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
# ~~~
fun len: Int `{
- uint32_t s = *recv;
+ uint32_t s = *self;
if(s <= 127) {return 1;}
if(s >= 49280 && s <= 57279) {return 2;}
if(s >= 14712960 && s <= 15712191) {return 3;}
#
# Note : A unicode character might not be a visible glyph, but it will be used to determine canonical equivalence
fun code_point: Int import UnicodeChar.len `{
- uint32_t val = *recv;
+ uint32_t val = *self;
uint32_t ret = 0;
- switch(UnicodeChar_len(recv)){
+ switch(UnicodeChar_len(self)){
case 1:
- ret = *recv;
+ ret = *self;
break;
case 2:
ret = 0 | ((val & 0x00001F00) >> 2) | (val & 0x0000003F);
# NOTE : Works only on ASCII chars
# TODO : Support unicode for to_upper
fun to_upper: UnicodeChar import UnicodeChar.code_point `{
- if(*recv < 97 || *recv > 122){ return recv; }
+ if(*self < 97 || *self > 122){ return self; }
uint32_t* ret = calloc(1,4);
- *ret = *recv - 32;
+ *ret = *self - 32;
return ret;
`}
# NOTE : Works only on ASCII chars
# TODO : Support unicode for to_upper
fun to_lower: UnicodeChar import UnicodeChar.code_point `{
- if(*recv < 65 || *recv > 90){ return recv; }
+ if(*self < 65 || *self > 90){ return self; }
uint32_t* ret = calloc(1,4);
- *ret = *recv + 32;
+ *ret = *self + 32;
return ret;
`}
end
redef fun output import UnicodeChar.len `{
- uint32_t self = *recv;
+ uint32_t self0 = *self;
if(!IS_BIG_ENDIAN){
- uint32_t tmp = ntohl(self);
- memcpy(&self, &tmp, 4);
+ uint32_t tmp = ntohl(self0);
+ memcpy(&self0, &tmp, 4);
}
- unsigned char* s = (unsigned char*) &self;
- switch(UnicodeChar_len(recv)){
+ unsigned char* s = (unsigned char*) &self0;
+ switch(UnicodeChar_len(self0)){
case 1:
printf("%c", s[3]);
break;
`}
redef fun to_s: FlatString import FlatString.full, UnicodeChar.len `{
- int len = UnicodeChar_len(recv);
+ int len = UnicodeChar_len(self);
char* r = malloc(len + 1);
r[len] = '\0';
- uint32_t src = *recv;
+ uint32_t src = *self;
if(!IS_BIG_ENDIAN){
uint32_t tmp = htonl(src);
memcpy(&src, &tmp, 4);
redef type OTHER: FlatString
# Length in bytes of the string (e.g. the length of the C string)
- redef var bytelen: Int
+ redef var bytelen
# Cache for the last accessed character in the char
var cache = new CharCache(-1,-1)
# Length implementation
private fun length_l: Int import FlatString.items, FlatString.index_to, FlatString.index_from `{
- char* ns = FlatString_items(recv);
- int i = FlatString_index_from(recv);
- int max = FlatString_index_to(recv);
+ char* ns = FlatString_items(self);
+ int i = FlatString_index_from(self);
+ int max = FlatString_index_to(self);
int length = 0;
while(i <= max){
char c = ns[i];
end
# O(n)
- redef fun substring(from: Int, count: Int) do
+ redef fun substring(from, count) do
assert count >= 0
if from < 0 then
redef class FlatBuffer
- redef var bytelen: Int
+ redef var bytelen
redef init from(s) do
if s isa Concat then
# Shifts the content of the buffer by `len` bytes to the right, starting at byte `from`
fun rshift_bytes(from: Int, len: Int) import FlatBuffer.bytelen, FlatBuffer.bytelen=, FlatBuffer.items `{
- long bt = FlatBuffer_bytelen(recv);
- char* ns = FlatBuffer_items(recv);
+ long bt = FlatBuffer_bytelen(self);
+ char* ns = FlatBuffer_items(self);
int off = from + len;
memmove(ns + off, ns + from, bt - from);
- FlatBuffer_bytelen__assign(recv, bt + len);
+ FlatBuffer_bytelen__assign(self, bt + len);
`}
# Shifts the content of the buffer by `len` bytes to the left, starting at `from`
fun lshift_bytes(from: Int, len: Int) import FlatBuffer.bytelen, FlatBuffer.bytelen=, FlatBuffer.items `{
- long bt = FlatBuffer_bytelen(recv);
- char* ns = FlatBuffer_items(recv);
+ long bt = FlatBuffer_bytelen(self);
+ char* ns = FlatBuffer_items(self);
int off = from - len;
memmove(ns + off, ns + from, bt - from);
- FlatBuffer_bytelen__assign(recv, bt - len);
+ FlatBuffer_bytelen__assign(self, bt - len);
`}
# Get the Unicode char stored at `index` in `self`
return to_s_with_length(len)
end
- redef fun to_s_with_length(len: Int): FlatString
+ redef fun to_s_with_length(len)
do
return new FlatString.with_bytelen(self, 0, len - 1, len)
end
end
# Do the full rendering and write the final content to a stream
- redef fun write_to(stream: Writer)
+ redef fun write_to(stream)
do
assert not is_writing
is_writing = true
import base64
intrude import standard::stream
+intrude import standard::bytes
# Websocket compatible listener
#
super TCPStream
init do
- _buffer = new FlatBuffer
+ _buffer = new NativeString(1024)
_buffer_pos = 0
+ _buffer_capacity = 1024
+ _buffer_length = 0
var headers = parse_handshake
var resp = handshake_response(headers)
end
# Frames a text message to be sent to a client
- private fun frame_message(msg: String): String
+ private fun frame_message(msg: String): Bytes
do
- var ans_buffer = new FlatBuffer
+ var ans_buffer = new Bytes.with_capacity(msg.length)
# Flag for final frame set to 1
# opcode set to 1 (for text)
- ans_buffer.add(129.ascii)
+ ans_buffer.add(129)
if msg.length < 126 then
- ans_buffer.add(msg.length.ascii)
+ ans_buffer.add(msg.length)
end
if msg.length >= 126 and msg.length <= 65535 then
- ans_buffer.add(126.ascii)
- ans_buffer.add(msg.length.rshift(8).ascii)
- ans_buffer.add(msg.length.ascii)
+ ans_buffer.add(126)
+ ans_buffer.add(msg.length.rshift(8))
+ ans_buffer.add(msg.length)
end
- ans_buffer.append(msg)
- return ans_buffer.to_s
+ if msg isa FlatString then
+ ans_buffer.append_ns_from(msg.items, msg.length, msg.index_from)
+ else
+ for i in msg.substrings do
+ ans_buffer.append_ns_from(i.as(FlatString).items, i.length, i.as(FlatString).index_from)
+ end
+ end
+ return ans_buffer
end
# Reads an HTTP frame
# Gets the message from the client, unpads it and reconstitutes the message
private fun unpad_message do
var fin = false
+ var bf = new Bytes.empty
while not fin do
var fst_byte = client.read_byte
var snd_byte = client.read_byte
if fin_flag != 0 then fin = true
var opcode = fst_byte.bin_and(15)
if opcode == 9 then
- _buffer.add(138.ascii)
- _buffer.add('\0')
- client.write(_buffer.to_s)
- _buffer_pos += 2
+ bf.add(138)
+ bf.add(0)
+ client.write(bf.to_s)
+ _buffer_pos = _buffer_length
return
end
if opcode == 8 then
var len = snd_byte.bin_and(127)
var payload_ext_len = 0
if len == 126 then
- var tmp = client.read(2)
+ var tmp = client.read_bytes(2)
if tmp.length != 2 then
last_error = new IOError("Error: received interrupted frame")
client.close
return
end
- payload_ext_len = tmp[1].ascii + tmp[0].ascii.lshift(8)
+ payload_ext_len = tmp[1] + tmp[0].lshift(8)
else if len == 127 then
# 64 bits for length are not supported,
# only the last 32 will be interpreted as a Nit Integer
- var tmp = client.read(8)
+ var tmp = client.read_bytes(8)
if tmp.length != 8 then
last_error = new IOError("Error: received interrupted frame")
client.close
return
end
for pos in [0 .. tmp.length[ do
- var i = tmp[pos].ascii
+ var i = tmp[pos]
payload_ext_len += i.lshift(8 * (7 - pos))
end
end
if mask_flag != 0 then
+ var mask = client.read_bytes(4).items
if payload_ext_len != 0 then
- var msg = client.read(payload_ext_len+4)
- var mask = msg.substring(0,4)
- _buffer.append(unmask_message(mask, msg.substring(4, payload_ext_len)))
- else
- if len == 0 then
- return
- end
- var msg = client.read(len+4)
- var mask = msg.substring(0,4)
- _buffer.append(unmask_message(mask, msg.substring(4, len)))
+ len = payload_ext_len
end
+ var msg = client.read_bytes(len).items
+ bf.append_ns(unmask_message(mask, msg, len), len)
end
end
+ _buffer = bf.items
+ _buffer_length = bf.length
end
# Unmasks a message sent by a client
- private fun unmask_message(key: String, message: String): String
+ private fun unmask_message(key: NativeString, message: NativeString, len: Int): NativeString
do
- var return_message = new FlatBuffer.with_capacity(message.length)
- var msg_iter = message.chars.iterator
+ var return_message = new NativeString(len)
- while msg_iter.is_ok do
- return_message.chars[msg_iter.index] = msg_iter.item.ascii.bin_xor(key.chars[msg_iter.index%4].ascii).ascii
- msg_iter.next
+ for i in [0 .. len[ do
+ return_message[i] = message[i].ascii.bin_xor(key[i%4].ascii).ascii
end
- return return_message.to_s
+ return return_message
end
# Checks if a connection to a client is available
redef fun connected do return client.connected
- redef fun write(msg)
- do
- client.write(frame_message(msg.to_s))
- end
+ redef fun write_bytes(s) do client.write_bytes(frame_message(s.to_s))
+
+ redef fun write(msg) do client.write(frame_message(msg.to_s).to_s)
redef fun is_writable do return client.connected
redef fun fill_buffer
do
- _buffer.clear
- _buffer_pos = 0
+ buffer_reset
unpad_message
end
- redef fun end_reached do return client._buffer_pos >= client._buffer.length and client.end_reached
+ redef fun end_reached do return client._buffer_pos >= client._buffer_length and client.end_reached
# Is there some data available to be read ?
fun can_read(timeout: Int): Bool do return client.ready_to_read(timeout)
fun is_valid: Bool do return not address_is_null
# Wipe handle of XDG data cache.
- fun destroy `{ xdgWipeHandle(recv); `}
+ fun destroy `{ xdgWipeHandle(self); `}
# Update the data cache.
#
# be used to access XDG data as it was before `update` was called.
#
# Returns `true` if the update was successful.
- fun update: Bool `{ return xdgUpdateData(recv); `}
+ fun update: Bool `{ return xdgUpdateData(self); `}
# Base directory for user specific data files.
fun data_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgDataHome(recv));
+ return NativeString_to_s((char*)xdgDataHome(self));
`}
# Base directory for user specific configuration files.
fun config_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgConfigHome(recv));
+ return NativeString_to_s((char*)xdgConfigHome(self));
`}
# Base directory for user specific non-essential data files.
fun cache_home: String import NativeString.to_s `{
- return NativeString_to_s((char*)xdgCacheHome(recv));
+ return NativeString_to_s((char*)xdgCacheHome(self));
`}
# Preference-ordered set of base directories to search for data files
fun data_dirs: Array[String] do return native_data_dirs.to_string_array
private fun native_data_dirs: ConstPointer `{
- return xdgDataDirectories(recv);
+ return xdgDataDirectories(self);
`}
# Preference-ordered set of base directories to search for data files
end
private fun native_searchable_data_dirs: ConstPointer `{
- return xdgSearchableDataDirectories(recv);
+ return xdgSearchableDataDirectories(self);
`}
# Preference-ordered set of base directories to search for configuration
fun config_dirs: Array[String] do return native_config_dirs.to_string_array
private fun native_config_dirs: ConstPointer `{
- return xdgConfigDirectories(recv);
+ return xdgConfigDirectories(self);
`}
# Preference-ordered set of base directories to search for configuration
end
private fun native_searchable_config_dirs: ConstPointer `{
- return xdgSearchableConfigDirectories(recv);
+ return xdgSearchableConfigDirectories(self);
`}
end
# Convert a C `char **` to a Nit `Array[String]`
fun to_string_array: Array[String]
import Array[String], Array[String].add, NativeString.to_s `{
- char **strings = (char**)recv;
+ char **strings = (char**)self;
Array_of_String aos = new_Array_of_String();
int p = 0;
# DESCRIPTION
-`nitx` in an interactive tool that display information about programs and libraries.
+`nitx` in an interactive tool that displays informations about programs and libraries.
-A command that query some information can be given as and argument.
+A command that query some information can be given as parameter.
This will immediately displays the information then terminates the programs.
If no command are given, the program starts an interactive session where commands are entered until `:q` is given.
`new: Type`
: lookup methods creating new instances of 'Type'.
+`call: Property`
+: lookup calls to 'Property'.
+
+`doc: name`
+: lookup documentation pages about 'name'.
+
+`code: name`
+: lookup source code related to 'name'.
+
`:h`
: display an help message about the commands.
# OPTIONS
-Only common options of the Nit tools are understood.
+`-q`
+: execute a query, display results in console then quit.
# SEE ALSO
if mproperty.is_init then
var recv_mtype = recv_mtype
recv_var = nitni_visitor.init_instance_or_extern(recv_mtype)
- nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
- nitni_visitor.add("recv = {recv_var};")
+ nitni_visitor.add("{mtype.ctype} self /* var self: {mtype} */;")
+ nitni_visitor.add("self = {recv_var};")
else
mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
- recv_var = nitni_visitor.var_from_c("recv", mtype)
+ recv_var = nitni_visitor.var_from_c("self", mtype)
recv_var = nitni_visitor.box_extern(recv_var, mtype)
end
var vars = new Array[RuntimeVariable]
- var recv_var = nitni_visitor.var_from_c("recv", mclass_type)
+ var recv_var = nitni_visitor.var_from_c("self", mclass_type)
recv_var = nitni_visitor.box_extern(recv_var, mclass_type)
vars.add(recv_var)
res.is_exact = true
if is_native_array then
var mtype_elt = mtype.arguments.first
- v.add("{res} = nit_alloc(sizeof(struct {mtype.c_name}) + length*sizeof({mtype_elt.ctype}));")
+ v.add("{res} = nit_alloc(sizeof(struct {mtype.c_name}) + length*sizeof(val*));")
v.add("((struct {mtype.c_name}*){res})->length = length;")
else
v.add("{res} = nit_alloc(sizeof(struct {mtype.c_name}));")
end
v.add_decl("\},")
else
- v.add_decl("0, \{\}, /*DEAD TYPE*/")
+ # Use -1 to indicate dead type, the info is used by --hardening
+ v.add_decl("-1, \{\}, /*DEAD TYPE*/")
end
v.add_decl("\};")
end
v.add("if({t} == NULL) \{")
v.add_abort("type null")
v.add("\}")
- v.add("if({t}->table_size == 0) \{")
+ v.add("if({t}->table_size < 0) \{")
v.add("PRINT_ERROR(\"Insantiation of a dead type: %s\\n\", {t}->name);")
v.add_abort("type dead")
v.add("\}")
#
# See module `console`.
fun cs_visibility_color(string: String): String do return string.green
+
+ # Source code associated to this MEntity.
+ #
+ # Uses `cs_location` to locate the source code.
+ fun cs_source_code: String do
+ # FIXME up location to mentity
+ var loc = new Location.from_string(cs_location)
+ var fr = new FileReader.open(loc.file.filename)
+ var content = new FlatBuffer
+ var i = 0
+ while not fr.eof do
+ i += 1
+ var line = fr.read_line
+ if i < loc.line_start or i > loc.line_end then continue
+ # FIXME add nitlight for console
+ content.append "{line}\n"
+ end
+ fr.close
+ return content.write_to_string
+ end
end
redef class MProject
# It is a placeholder to share data between each phase.
class DocModel
- # `DocPage` composing the documentation.
+ # `DocPage` composing the documentation associated to their ids.
#
# This is where `DocPhase` store and access pages to produce documentation.
- var pages = new Array[DocPage]
+ #
+ # See `add_page`.
+ var pages: Map[String, DocPage] = new HashMap[String, DocPage]
# Nit `Model` from which we extract the documentation.
var model: Model is writable
# The entry point of the `model`.
var mainmodule: MModule is writable
+
+ # Add a `page` to this documentation.
+ fun add_page(page: DocPage) do
+ if pages.has_key(page.id) then
+ print "Warning: multiple page with the same id `{page.id}`"
+ end
+ pages[page.id] = page
+ end
end
# A documentation page abstraction.
# the page.
class DocPage
+ # Page uniq id.
+ #
+ # The `id` is used as name for the generated file corresponding to the page
+ # (if any).
+ # Because multiple pages can be generated in the same directory it should be
+ # uniq.
+ #
+ # The `id` can also be used to establish links between pages (HTML links,
+ # HTML anchors, vim links, etc.).
+ var id: String is writable
+
# Title of this page.
var title: String is writable
end
redef class MEntity
+ # ID used as a unique ID and in file names.
+ #
+ # **Must** match the following (POSIX ERE) regular expression:
+ #
+ # ~~~POSIX ERE
+ # ^[A-Za-z_][A-Za-z0-9._-]*$
+ # ~~~
+ #
+ # That way, the ID is always a valid URI component and a valid XML name.
+ fun nitdoc_id: String do return full_name.to_cmangle
+
# Name displayed in console for debug and tests.
fun nitdoc_name: String do return name.html_escape
end
+redef class MModule
+
+ # Avoid id conflict with group
+ redef fun nitdoc_id do
+ if mgroup == null then return super
+ return "{mgroup.full_name}::{full_name}".to_cmangle
+ end
+end
+
redef class MClassDef
redef fun nitdoc_name do return mclass.nitdoc_name
end
# Populates the given DocModel.
redef fun apply do
- for page in doc.pages do page.build_concerns(doc)
+ for page in doc.pages.values do page.build_concerns(doc)
end
end
module doc_console
import semantize
+import doc_extract
import doc::console_templates
# Nitx handles console I/O.
fun help do
print "\nCommands:"
print "\tname\t\tlookup module, class and property with the corresponding 'name'"
+ print "\tdoc: <name::space>\tdisplay the documentation page of 'namespace'"
+ print "\tparam: <Type>\tlookup methods using the corresponding 'Type' as parameter"
+ print "\treturn: <Type>\tlookup methods returning the corresponding 'Type'"
+ print "\tnew: <Type>\tlookup methods creating new instances of 'Type'"
+ print "\tcall: <name>\tlookup methods calling 'name'"
+ print "\tcode: <name>\tdisplay the source code associated to the 'name' entity"
print "\t:h\t\tdisplay this help message"
print "\t:q\t\tquit interactive mode"
print ""
return new NitxHelp
else if query_string.has_prefix("comment:") then
return new CommentQuery(query_string)
+ else if query_string.has_prefix("doc:") then
+ return new DocQuery(query_string)
+ else if query_string.has_prefix("param:") then
+ return new ParamQuery(query_string)
+ else if query_string.has_prefix("return:") then
+ return new ReturnQuery(query_string)
+ else if query_string.has_prefix("new:") then
+ return new NewQuery(query_string)
+ else if query_string.has_prefix("call:") then
+ return new CallQuery(query_string)
+ else if query_string.has_prefix("code:") then
+ return new CodeQuery(query_string)
+
end
return new CommentQuery("comment: {query_string}")
end
# Pretty prints the results for the console.
fun make_results(nitx: Nitx, results: Array[NitxMatch]): DocPage do
- var page = new DocPage("Results")
+ var page = new DocPage("results", "Results")
page.root.add_child(new QueryResultArticle(self, results))
return page
end
redef fun perform(nitx, doc) do
var name = args.first
var res = new Array[NitxMatch]
- for mentity in doc.search_mentities(name) do
+ for mentity in doc.mentities_by_name(name) do
res.add new MEntityMatch(self, mentity)
end
return res
if len == 1 then
var res = results.first.as(MEntityMatch)
var mentity = res.mentity
- var page = new DocPage("Results")
+ var page = new DocPage("resultats", "Results")
var article = new DefinitionArticle(mentity)
article.cs_title = mentity.name
article.cs_subtitle = mentity.cs_declaration
end
end
+# A query to search signatures using a specific `MType` as parameter.
+class ParamQuery
+ super MetaQuery
+
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var mtype_name = args.first
+ for mproperty in doc.mproperties do
+ if not mproperty isa MMethod then continue
+ var msignature = mproperty.intro.msignature
+ if msignature != null then
+ for mparam in msignature.mparameters do
+ if mparam.mtype.name == mtype_name then
+ res.add new MEntityMatch(self, mproperty)
+ end
+ end
+ end
+ end
+ return res
+ end
+end
+
+# A query to search signatures using a specific `MType` as return.
+class ReturnQuery
+ super MetaQuery
+
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var mtype_name = args.first
+ for mproperty in doc.mproperties do
+ if not mproperty isa MMethod then continue
+ var msignature = mproperty.intro.msignature
+ if msignature != null then
+ var mreturn = msignature.return_mtype
+ if mreturn != null and mreturn.name == mtype_name then
+ res.add new MEntityMatch(self, mproperty)
+ end
+ end
+ end
+ return res
+ end
+end
+
+# A query to search methods creating new instances of a specific `MType`.
+class NewQuery
+ super MetaQuery
+
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var mtype_name = args.first
+ for mpropdef in doc.mpropdefs do
+ var visitor = new TypeInitVisitor(mtype_name)
+ var npropdef = nitx.ctx.modelbuilder.mpropdef2node(mpropdef)
+ if npropdef == null then continue
+ visitor.enter_visit(npropdef)
+ for i in visitor.inits do
+ res.add new MEntityMatch(self, mpropdef)
+ end
+ end
+ return res
+ end
+end
+
+# A query to search methods calling a specific `MProperty`.
+class CallQuery
+ super MetaQuery
+
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var mprop_name = args.first
+ for mpropdef in doc.mpropdefs do
+ var visitor = new MPropertyCallVisitor
+ var npropdef = nitx.ctx.modelbuilder.mpropdef2node(mpropdef)
+ if npropdef == null then continue
+ visitor.enter_visit(npropdef)
+ for mprop in visitor.calls do
+ if mprop.name != mprop_name then continue
+ res.add new MEntityMatch(self, mpropdef)
+ end
+ end
+ return res
+ end
+end
+
+# A query to search a Nitdoc documentation page by its name.
+class DocQuery
+ super MetaQuery
+
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var name = args.first
+ for page in doc.pages.values do
+ if name == "*" then # FIXME dev only
+ res.add new PageMatch(self, page)
+ else if page.title == name then
+ res.add new PageMatch(self, page)
+ else if page isa MEntityPage and page.mentity.cs_namespace == name then
+ res.add new PageMatch(self, page)
+ end
+ end
+ return res
+ end
+
+ redef fun make_results(nitx, results) do
+ var len = results.length
+ # FIXME how to render the pager for one worded namespaces like "standard"?
+ if len == 1 then
+ var page = results.first.as(PageMatch).page
+ var pager = new Pager
+ pager.add page.write_to_string
+ pager.render
+ return page
+ else
+ return super
+ end
+ end
+end
+
+# A match between a `DocPage` and a `MEntity`.
+class PageMatch
+ super NitxMatch
+
+ # `DocPage` matched.
+ var page: DocPage
+
+ redef fun make_list_item do
+ var page = self.page
+ if page isa MEntityPage then
+ return page.mentity.cs_list_item
+ end
+ return " * {page.title}"
+ end
+end
+
+# A query to search source code from a file name.
+class CodeQuery
+ super MetaQuery
+
+ # FIXME refactor this!
+ redef fun perform(nitx, doc) do
+ var res = new Array[NitxMatch]
+ var name = args.first
+ # if name is an existing sourcefile, opens it
+ if name.file_exists then
+ var fr = new FileReader.open(name)
+ var content = fr.read_all
+ fr.close
+ res.add new CodeMatch(self, name, content)
+ return res
+ end
+ # else, lookup the model by name
+ for mentity in doc.mentities_by_name(name) do
+ if mentity isa MClass then continue
+ if mentity isa MProperty then continue
+ res.add new CodeMatch(self, mentity.cs_location, mentity.cs_source_code)
+ end
+ return res
+ end
+
+ redef fun make_results(nitx, results) do
+ var page = new DocPage("results", "Code Results")
+ for res in results do
+ page.add new CodeQueryArticle(self, res.as(CodeMatch))
+ end
+ return page
+ end
+end
+
+# A match between a piece of code and a string.
+class CodeMatch
+ super NitxMatch
+
+ # Location of the code match.
+ var location: String
+
+ # Piece of code matched.
+ var content: String
+
+ redef fun make_list_item do return "* {location}"
+end
+
+
# A query that contains a nitx command.
#
# These commands are prefixed with `:` and are used to control the execution of
## exploration
-redef class DocModel
-
- # Lists all MEntities in the model.
- private var mentities: Collection[MEntity] is lazy do
- var res = new HashSet[MEntity]
- res.add_all mprojects
- res.add_all mgroups
- res.add_all mmodules
- res.add_all mclasses
- res.add_all mclassdefs
- res.add_all mproperties
- res.add_all mpropdefs
- return res
+# Visitor looking for initialized `MType` (new T).
+#
+# See `NewQuery`.
+private class TypeInitVisitor
+ super Visitor
+
+ # `MType` name to look for.
+ var mtype_name: String
+
+ var inits = new HashSet[MType]
+ redef fun visit(node)
+ do
+ node.visit_all(self)
+ # look for init
+ if not node isa ANewExpr then return
+ var mtype = node.n_type.mtype
+ if mtype != null and mtype.name == mtype_name then inits.add(mtype)
end
+end
- # Search MEntities that match `name` by their name or namespace.
- private fun search_mentities(name: String): Array[MEntity] do
- var res = new Array[MEntity]
- for mentity in mentities do
- if mentity.name != name and mentity.cs_namespace != name then continue
- res.add mentity
- end
- return res
+# Visitor looking for calls to a `MProperty` (new T).
+#
+# See `CallQuery`.
+private class MPropertyCallVisitor
+ super Visitor
+
+ var calls = new HashSet[MProperty]
+ redef fun visit(node)
+ do
+ node.visit_all(self)
+ if not node isa ASendExpr then return
+ calls.add node.callsite.mproperty
end
end
end
end
+# An article that displays a piece of code.
+private class CodeQueryArticle
+ super DocArticle
+
+ # The query linked to the result to display.
+ var query: NitxQuery
+
+ # The result to display.
+ var result: CodeMatch
+
+ redef fun render_body do
+ addn ""
+ addn "in {result.location}".gray.bold
+ addn ""
+ add result.content
+ end
+end
+
# A Pager is used to display data into a unix `less` container.
private class Pager
end
end
end
+
+ # Lists all MEntities in the model.
+ #
+ # FIXME invalidate cache if `self` is modified.
+ var mentities: Collection[MEntity] is lazy do
+ var res = new HashSet[MEntity]
+ res.add_all mprojects
+ res.add_all mgroups
+ res.add_all mmodules
+ res.add_all mclasses
+ res.add_all mclassdefs
+ res.add_all mproperties
+ res.add_all mpropdefs
+ return res
+ end
+
+ # Searches MEntities that match `name`.
+ fun mentities_by_name(name: String): Array[MEntity] do
+ var res = new Array[MEntity]
+ for mentity in mentities do
+ if mentity.name != name then continue
+ res.add mentity
+ end
+ return res
+ end
+
+ # Looks up a MEntity by its `namespace`.
+ #
+ # Usefull when `mentities_by_name` by return conflicts.
+ #
+ # Path can be the shortest possible to disambiguise like `Class::property`.
+ # In case of larger conflicts, a more complex namespace can be given like
+ # `project::module::Class::prop`.
+ fun mentities_by_namespace(namespace: String): Array[MEntity] do
+ var res = new Array[MEntity]
+ for mentity in mentities do
+ mentity.mentities_by_namespace(namespace, res)
+ end
+ return res
+ end
+end
+
+redef class MEntity
+ # Looks up a MEntity by its `namespace` from `self`.
+ private fun mentities_by_namespace(namespace: String, res: Array[MEntity]) do end
+
+ private fun lookup_in(mentities: Collection[MEntity], namespace: String, res: Array[MEntity]) do
+ var parts = namespace.split_once_on("::")
+ var name = parts.shift
+ for mentity in mentities do
+ if mentity.name != name then continue
+ if parts.is_empty then
+ res.add mentity
+ else
+ mentity.mentities_by_namespace(parts.first, res)
+ end
+ end
+ end
+end
+
+redef class MProject
+ redef fun mentities_by_namespace(namespace, res) do lookup_in(mgroups, namespace, res)
+end
+
+redef class MGroup
+ redef fun mentities_by_namespace(namespace, res) do lookup_in(mmodules, namespace, res)
+end
+
+redef class MModule
+ redef fun mentities_by_namespace(namespace, res) do lookup_in(mclassdefs, namespace, res)
+end
+
+redef class MClassDef
+ redef fun mentities_by_namespace(namespace, res) do lookup_in(mpropdefs, namespace, res)
end
redef fun apply do
if ctx.opt_nodot.value then return
- for page in doc.pages do
+ for page in doc.pages.values do
var article = page.build_graph(self, doc)
if article == null then continue
# FIXME avoid diff
var name_sorter = new MEntityNameSorter
redef fun apply do
- for page in doc.pages do
+ for page in doc.pages.values do
if page isa MEntityPage then page.build_inh_list(self, doc)
end
end
redef fun apply do
init_output_dir
- for page in doc.pages do
+ for page in doc.pages.values do
page.render(self, doc).write_to_file("{ctx.output_dir.to_s}/{page.html_url}")
end
end
# all properties below are roughly copied from `doc_pages`
# Build page title string
- fun init_title(v: RenderHTMLPhase, doc: DocModel) is abstract
+ fun init_title(v: RenderHTMLPhase, doc: DocModel) do end
# Build top menu template if any.
fun init_topmenu(v: RenderHTMLPhase, doc: DocModel) do
super DocPhase
redef fun apply do
- for page in doc.pages do
+ for page in doc.pages.values do
if not page isa MEntityPage then continue
page.root.build_intro_redef_list(self, doc, page)
end
private var lin_sorter = new MEntityNameSorter
redef fun apply do
- for page in doc.pages do page.apply_linearization(self, doc)
+ for page in doc.pages.values do page.apply_linearization(self, doc)
end
end
# Instanciates documentation pages for the given DocModel.
redef fun apply do
- doc.pages.add new OverviewPage("Overview")
- doc.pages.add new SearchPage("Index")
+ doc.add_page new OverviewPage("overview", "Overview")
+ doc.add_page new SearchPage("search", "Index")
for mgroup in doc.mgroups do
- doc.pages.add new MGroupPage(mgroup.nitdoc_name, mgroup)
+ doc.add_page new MGroupPage(mgroup)
end
for mmodule in doc.mmodules do
- doc.pages.add new MModulePage(mmodule.nitdoc_name, mmodule)
+ doc.add_page new MModulePage(mmodule)
end
for mclass in doc.mclasses do
- doc.pages.add new MClassPage(mclass.nitdoc_name, mclass)
+ doc.add_page new MClassPage(mclass)
end
for mproperty in doc.mproperties do
- doc.pages.add new MPropertyPage(mproperty.nitdoc_name, mproperty)
+ doc.add_page new MPropertyPage(mproperty)
end
end
end
# A DocPage documenting a MEntity.
class MEntityPage
+ autoinit mentity
super DocPage
# Type of MEntity documented by this page.
# MEntity documented by this page.
var mentity: MENTITY
+
+ redef var id is lazy do return mentity.nitdoc_id
+ redef var title is lazy do return mentity.nitdoc_name
end
# A documentation page about a MGroup.
# Populates the given DocModel.
redef fun apply do
- for page in doc.pages do
+ for page in doc.pages.values do
if page isa MEntityPage then page.build_poset(self, doc)
end
end
# Populates the given DocModel.
redef fun apply do
- for page in doc.pages do page.apply_structure(self, doc)
+ for page in doc.pages.values do page.apply_structure(self, doc)
end
end
import ordered_tree
redef class MEntity
- # ID used as a HTML unique ID and in file names.
- #
- # **Must** match the following (POSIX ERE) regular expression:
- #
- # ~~~POSIX ERE
- # ^[A-Za-z_][A-Za-z0-9._-]*$
- # ~~~
- #
- # That way, the ID is always a valid URI component and a valid XML name.
- fun nitdoc_id: String is abstract
-
# URL of this entity’s Nitdoc page.
fun nitdoc_url: String is abstract
# Will convert C arguments to C++ and call the C++ implementation function.
fc = new CFunction(indirection_sig)
if not mproperty.is_init then
- var param_name = "recv"
+ var param_name = "self"
var type_name = to_cpp_call_context.name_mtype(mclass_type)
if mclass_type.mclass.ftype isa ForeignCppType then
fc.exprs.add("{type_name} {param_name}_for_cpp = static_cast<{type_name}>({param_name});\n")
jni_signature_alt = mclass_type.jni_signature_alt
return_type = mclass_type
else
- params.add "recv"
+ params.add "self"
if signature.return_mtype != null then
var ret_mtype = signature.return_mtype
ret_mtype = ret_mtype.resolve_for(mclass_type, mclass_type, mmodule, true)
cparams.add "jclass clazz"
if not self.is_init then
- cparams.add "{call_context.name_mtype(recv_mtype)} recv"
+ cparams.add "{call_context.name_mtype(recv_mtype)} self"
end
for p in signature.mparameters do
var param_mtype = p.mtype.resolve_for(recv_mtype, recv_mtype, from_mmodule, true)
writable
autoinit
noautoinit
+lateinit
nosuper
old_style_init
abstract
module debugger
intrude import naive_interpreter
-import nitx
intrude import semantize::local_var_init
intrude import semantize::scope
intrude import toolcontext
else if command == "help" then
help
return true
- # Opens a new NitIndex prompt on current model
- else if command == "nitx" then
- new NitIndex.with_infos(modelbuilder, self.mainmodule).prompt
- return true
else if command == "bt" or command == "backtrack" then
print stack_trace
return true
end
end
+redef class Text
+ private fun remove_underscores: Text do
+ var b = new FlatBuffer
+ for i in chars do
+ if i == '_' then continue
+ b.add i
+ end
+ return b
+ end
+end
redef class AIntExpr
# The value of the literal int once computed.
redef class ADecIntExpr
redef fun accept_literal(v)
do
- self.value = self.n_number.text.to_i
+ value = self.n_number.text.to_i
end
end
redef class AHexIntExpr
redef fun accept_literal(v)
do
- self.value = self.n_hex_number.text.substring_from(2).to_hex
+ var s = self.n_hex_number.text.substring_from(2).remove_underscores
+ if s.is_empty then
+ v.toolcontext.error(location, "Error: invalid hexadecimal literal")
+ return
+ end
+ value = s.to_hex
+ end
+end
+
+redef class ABinIntExpr
+ redef fun accept_literal(v)
+ do
+ var s = self.n_bin_number.text.substring_from(2).remove_underscores
+ if s.is_empty then
+ v.toolcontext.error(location, "Error: invalid binary literal")
+ return
+ end
+ value = s.to_bin
+ end
+end
+
+redef class AOctIntExpr
+ redef fun accept_literal(v)
+ do
+ var s = self.n_oct_number.text.substring_from(2).remove_underscores
+ if s.is_empty then
+ v.toolcontext.error(location, "Error: invalid octal literal")
+ return
+ end
+ value = s.to_oct
end
end
var mreadpropdef = npropdef.mreadpropdef
if mreadpropdef == null or mreadpropdef.msignature == null then return # Skip broken attribute
if npropdef.noinit then continue # Skip noinit attribute
- var atautoinit = npropdef.get_single_annotation("autoinit", self)
- if atautoinit != null then
- # For autoinit attributes, call the reader to force
+ var atlateinit = npropdef.get_single_annotation("lateinit", self)
+ if atlateinit != null then
+ # For lateinit attributes, call the reader to force
# the lazy initialization of the attribute.
initializers.add(mreadpropdef.mproperty)
mreadpropdef.mproperty.is_autoinit = true
abort
end
end
- else if noautoinit != null then
- if initializers.is_empty then
- warning(noautoinit, "useless-noautoinit", "Warning: the list of autoinit is already empty.")
- end
- # Just clear initializers
- mparameters.clear
- initializers.clear
else
# Search the longest-one and checks for conflict
var longest = spropdefs.first
if spropdefs.length > 1 then
- # Check for conflict in the order of initializers
- # Each initializer list must me a prefix of the longest list
# part 1. find the longest list
for spd in spropdefs do
if spd.initializers.length > longest.initializers.length then longest = spd
end
# part 2. compare
- for spd in spropdefs do
+ # Check for conflict in the order of initializers
+ # Each initializer list must me a prefix of the longest list
+ # If `noautoinit` is set, just ignore conflicts
+ if noautoinit == null then for spd in spropdefs do
var i = 0
for p in spd.initializers do
if p != longest.initializers[i] then
end
end
- # Can we just inherit?
- if spropdefs.length == 1 and mparameters.is_empty and defined_init == null then
- self.toolcontext.info("{mclassdef} inherits the basic constructor {longest}", 3)
- mclassdef.mclass.root_init = longest
- return
- end
+ if noautoinit != null then
+ # If there is local or inherited initializers, then complain.
+ if initializers.is_empty and longest.initializers.is_empty then
+ warning(noautoinit, "useless-noautoinit", "Warning: the list of autoinit is already empty.")
+ end
+ # Just clear initializers
+ mparameters.clear
+ initializers.clear
+ else
+ # Can we just inherit?
+ if spropdefs.length == 1 and mparameters.is_empty and defined_init == null then
+ self.toolcontext.info("{mclassdef} inherits the basic constructor {longest}", 3)
+ mclassdef.mclass.root_init = longest
+ return
+ end
- # Combine the inherited list to what is collected
- if longest.initializers.length > 0 then
- mparameters.prepend longest.new_msignature.mparameters
- initializers.prepend longest.initializers
+ # Combine the inherited list to what is collected
+ if longest.initializers.length > 0 then
+ mparameters.prepend longest.new_msignature.mparameters
+ initializers.prepend longest.initializers
+ end
end
end
return true
end
+ # Checks for useless type in redef signatures.
+ private fun check_repeated_types(modelbuilder: ModelBuilder) do end
end
redef class ASignature
var nt = nsig.n_type
if nt != null then modelbuilder.check_visibility(nt, nt.mtype.as(not null), mpropdef)
end
+ check_repeated_types(modelbuilder)
+ end
+
+ # For parameters, type is always useless in a redef.
+ # For return type, type is useless if not covariant with introduction.
+ redef fun check_repeated_types(modelbuilder) do
+ if mpropdef.is_intro or n_signature == null then return
+ # check params
+ for param in n_signature.n_params do
+ if param.n_type != null then
+ modelbuilder.advice(param.n_type, "useless-signature", "Warning: useless type repetition on parameter `{param.n_id.text}` for redefined method `{mpropdef.name}`")
+ end
+ end
+ # get intro
+ var intro = mpropdef.mproperty.intro
+ var n_intro = modelbuilder.mpropdef2npropdef.get_or_null(intro)
+ if n_intro == null or not n_intro isa AMethPropdef then return
+ # check return type
+ var ret_type = n_signature.ret_type
+ if ret_type != null and ret_type == n_intro.n_signature.ret_type then
+ modelbuilder.advice(n_signature.n_type, "useless-signature", "Warning: useless return type repetition for redefined method `{mpropdef.name}`")
+ end
end
end
end
var atlazy = self.get_single_annotation("lazy", modelbuilder)
- var atautoinit = self.get_single_annotation("autoinit", modelbuilder)
- if atlazy != null or atautoinit != null then
- if atlazy != null and atautoinit != null then
- modelbuilder.error(atlazy, "Error: `lazy` incompatible with `autoinit`.")
+ var atlateinit = self.get_single_annotation("lateinit", modelbuilder)
+ if atlazy != null or atlateinit != null then
+ if atlazy != null and atlateinit != null then
+ modelbuilder.error(atlazy, "Error: `lazy` incompatible with `lateinit`.")
return
end
if not has_value then
if atlazy != null then
modelbuilder.error(atlazy, "Error: `lazy` attributes need a value.")
- else if atautoinit != null then
- modelbuilder.error(atautoinit, "Error: `autoinit` attributes need a value.")
+ else if atlateinit != null then
+ modelbuilder.error(atlateinit, "Error: `lateinit` attributes need a value.")
end
has_value = true
return
if mlazypropdef != null then
mlazypropdef.static_mtype = modelbuilder.model.get_mclasses_by_name("Bool").first.mclass_type
end
+ check_repeated_types(modelbuilder)
end
redef fun check_signature(modelbuilder)
end
end
end
+
+ # Type is useless if the attribute type is the same thant the intro.
+ redef fun check_repeated_types(modelbuilder) do
+ if mreadpropdef.is_intro or n_type == null then return
+ # get intro
+ var intro = mreadpropdef.mproperty.intro
+ var n_intro = modelbuilder.mpropdef2npropdef.get_or_null(intro)
+ if n_intro == null then return
+ # get intro type
+ var ntype = null
+ if n_intro isa AMethPropdef then
+ ntype = n_intro.n_signature.ret_type
+ else if n_intro isa AAttrPropdef and n_intro.n_type != null then
+ ntype = n_intro.n_type.mtype
+ end
+ # check
+ if ntype ==null or ntype != n_type.mtype then return
+ modelbuilder.advice(n_type, "useless-signature", "Warning: useless type repetition on redefined attribute `{mpropdef.name}`")
+ end
end
redef class ATypePropdef
var cparams = new List[String]
if not self.is_init then
- cparams.add( "{call_context.name_mtype(recv_mtype)} recv" )
+ cparams.add( "{call_context.name_mtype(recv_mtype)} self" )
end
for p in signature.mparameters do
var param_mtype = p.mtype.resolve_for(recv_mtype, recv_mtype, from_mmodule, true)
var cparams = new List[String]
if not self.is_init then
- cparams.add(call_context.cast_to(recv_mtype, "recv{param_suffix}"))
+ cparams.add(call_context.cast_to(recv_mtype, "self{param_suffix}"))
end
for p in signature.mparameters do
# A model builder to parse files
var modelbuilder = new ModelBuilder(model, toolcontext)
-# Here we load an process all modules passed on the command line
+# Here we load and process all modules passed on the command line
var mmodules = modelbuilder.parse_full(arguments)
toolcontext.mmodules_to_check.add_all mmodules
# See the License for the specific language governing permissions and
# limitations under the License.
-# nit index, is a command tool used to display documentation
+# `nitx`, is a command tool that displays useful informations about the code.
+#
+# Features:
+#
+# * Display comment from name/namespace
+# * Display documentation page from Nitdoc in console
+# * Find type usage in parameters, returns and news.
+# * Find usage of a specific property.
+# * Find source code related to class/property by its name.
module nitx
-import model_utils
-import modelize
-
-# Main class of the nit index tool
-# NitIndex build the model using the toolcontext argument
-# then wait for query on std in to display documentation
-class NitIndex
- private var toolcontext: ToolContext
- private var model: Model is noinit
- private var mbuilder: ModelBuilder is noinit
- private var mainmodule: MModule is noinit
- private var arguments: Array[String] is noinit
- private var renderer: PagerMatchesRenderer is noinit
-
- # New constructor to use the pre-calculated model when interpreting a module
- init with_infos(mbuilder: ModelBuilder, mmodule: MModule) do
-
- self.model = mbuilder.model
- self.mbuilder = mbuilder
-
- self.mainmodule = mmodule
- self.toolcontext = mbuilder.toolcontext
- self.arguments = toolcontext.option_context.rest
-
- renderer = new PagerMatchesRenderer(self)
- end
-
- init do
- # We need a model to collect stufs
- self.arguments = toolcontext.option_context.rest
-
- if arguments.length > 2 then
- print toolcontext.tooldescription
- exit(1)
- end
-
- model = new Model
- mbuilder = new ModelBuilder(model, toolcontext)
-
- var mmodules = mbuilder.parse([arguments.first])
- if mmodules.is_empty then return
- mbuilder.run_phases
- assert mmodules.length == 1
- self.mainmodule = mmodules.first
-
- renderer = new PagerMatchesRenderer(self)
- end
-
- fun start do
- if arguments.length == 1 then
- welcome
- prompt
- else
- search(arguments[1])
- end
- end
-
- fun welcome do
- print "Welcome in the Nit Index."
- print ""
- print "Loaded modules:"
- var mmodules = new Array[MModule]
- mmodules.add_all(model.mmodules)
- var sorter = new MEntityNameSorter
- sorter.sort(mmodules)
- for m in mmodules do
- print "\t{m.name}"
- end
- print ""
- help
- end
-
- fun help do
- print "\nCommands:"
- print "\tname\t\tlookup module, class and property with the corresponding 'name'"
- print "\tparam: Type\tlookup methods using the corresponding 'Type' as parameter"
- print "\treturn: Type\tlookup methods returning the corresponding 'Type'"
- print "\tnew: Type\tlookup methods creating new instances of 'Type'"
- print "\t:h\t\tdisplay this help message"
- print "\t:q\t\texit"
- print ""
- end
-
- fun prompt do
- printn ">> "
- search(sys.stdin.read_line)
- end
+import modelbuilder
+import doc::doc_phases::doc_console
- fun search(entry: String) do
- if entry.is_empty then
- prompt
- return
- end
- if entry == ":h" then
- help
- prompt
- return
- end
- if entry == ":q" then return
-
- # Parse query string
- var query = parse_query(entry)
-
- # search in index
- var matches = new HashSet[IndexMatch]
- if query isa IndexQueryPair then
- if query.category == "return" then
- # seek return types
- matches.add_all(search_returns(query))
- else if query.category == "param" then
- # seek param types
- matches.add_all(search_params(query))
- else if query.category == "new" then
- # seek type inits
- matches.add_all(search_inits(query))
- end
- else
- matches.add_all(search_modules(query))
- matches.add_all(search_classes(query))
- matches.add_all(search_properties(query))
- end
- # no matches
- if matches.is_empty then
- print "Nothing known about '{query.string}', type ':h' for help"
- else
- renderer.render_matches(query, matches)
- end
- if arguments.length == 1 then prompt
- end
-
- private fun parse_query(str: String): IndexQuery do
- var parts = str.split_with(":")
- if parts.length == 1 then
- return new IndexQuery(str, parts[0])
- else
- var category = parts[0]
- var keyword = parts[1]
- if keyword.chars.first == ' ' then keyword = keyword.substring_from(1)
- return new IndexQueryPair(str, keyword, category)
- end
- end
-
- # search for modules
- private fun search_modules(query: IndexQuery): Set[MModule] do
- var matches = new HashSet[MModule]
- for mmodule in model.mmodules do
- if mmodule.name == query.keyword then matches.add(mmodule)
- end
- return matches
- end
-
- # search for classes
- private fun search_classes(query: IndexQuery): Set[MClass] do
- var matches = new HashSet[MClass]
- for mclass in model.mclasses do
- if mclass.name == query.keyword then matches.add(mclass)
- end
- return matches
- end
-
- # search for properties
- private fun search_properties(query: IndexQuery): Set[MProperty] do
- var matches = new HashSet[MProperty]
- for mproperty in model.mproperties do
- if mproperty.name == query.keyword then matches.add(mproperty)
- end
- return matches
- end
-
- # search for mpropdef returning keyword
- private fun search_returns(query: IndexQuery): Set[MProperty] do
- var matches = new HashSet[MProperty]
- for mproperty in model.mproperties do
- var intro = mproperty.intro
- if intro isa MMethodDef then
- if intro.msignature.return_mtype != null and intro.msignature.return_mtype.to_console.has_prefix(query.keyword) then matches.add(mproperty)
- else if intro isa MAttributeDef then
- if intro.static_mtype.to_console.has_prefix(query.keyword) then matches.add(mproperty)
- end
- end
- return matches
- end
-
- # search for mpropdef taking keyword as parameter
- private fun search_params(query: IndexQuery): Set[MProperty] do
- var matches = new HashSet[MProperty]
- for mproperty in model.mproperties do
- var intro = mproperty.intro
- if intro isa MMethodDef then
- var mparameters = intro.msignature.mparameters
- for mparameter in mparameters do
- if mparameter.mtype.to_console.has_prefix(query.keyword) then matches.add(mproperty)
- end
- else if intro isa MAttributeDef then
- if intro.static_mtype.to_console.has_prefix(query.keyword) then matches.add(mproperty)
- end
- end
- return matches
- end
-
- # search for mpropdef creating new instance of keyword
- private fun search_inits(query: IndexQuery): Set[MPropDef] do
- var mtype2mpropdefs = toolcontext.nitx_phase.mtype2mpropdefs
- var matches = new HashSet[MPropDef]
- for mtype in mtype2mpropdefs.keys do
- if mtype.to_console.has_prefix(query.keyword) then
- for mpropdef in mtype2mpropdefs[mtype] do
- matches.add(mpropdef)
- end
- end
- end
- return matches
- end
-end
-
-private class IndexQuery
- var string: String
- var keyword: String
-end
-
-private class IndexQueryPair
- super IndexQuery
- var category: String
-end
+redef class ToolContext
-# A match to a query in the nit index
-private interface IndexMatch
- # Short preview of the result for result list display
- fun preview(index: NitIndex, output: Pager) is abstract
- fun content(index: NitIndex, output: Pager) is abstract
-end
+ # Nittx generation phase.
+ var docx: Phase = new NitxPhase(self, null)
-# Code Analysis
+ # Used to shortcut the prompt and display directly the result in console.
+ var opt_query = new OptionString("Nitx query to perform", "-q", "--query")
-redef class ToolContext
- private var nitx_phase: NitxPhase = new NitxPhase(self, [modelize_property_phase])
+ init do option_context.add_option opt_query
end
-# Compiler phase for nitx
+# Nitx phase explores the model and prepares the console rendering.
private class NitxPhase
super Phase
-
- var mtype2mpropdefs = new HashMap[MType, Set[MPropDef]]
- redef fun process_npropdef(npropdef) do
- var visitor = new TypeInitVisitor
- visitor.enter_visit(npropdef)
- for mtype in visitor.inits do
- if not mtype2mpropdefs.has_key(mtype) then
- mtype2mpropdefs[mtype] = new HashSet[MPropDef]
- end
- mtype2mpropdefs[mtype].add(npropdef.mpropdef.as(not null))
- end
- end
-end
-
-# Visitor looking for initialized mtype (new T)
-private class TypeInitVisitor
- super Visitor
-
- var inits = new HashSet[MType]
- redef fun visit(node)
+ redef fun process_mainmodule(mainmodule, mmodules)
do
- node.visit_all(self)
- # look for init
- if not node isa ANewExpr then return
- var mtype = node.n_type.mtype
- if mtype != null then inits.add(mtype)
- end
-end
-
-# Pager output for console
-
-private class PagerMatchesRenderer
- var index: NitIndex
-
- fun render_matches(query: IndexQuery, matches: Collection[IndexMatch]) do
- var pager = new Pager
- if matches.length == 1 then
- pager.add("= result for '{query.string}'".bold)
- pager.add("")
- pager.indent = pager.indent + 1
- matches.first.content(index, pager)
- pager.indent = pager.indent - 1
- else
- pager.add("= multiple results for '{query.string}'".bold)
- pager.indent = pager.indent + 1
- for match in matches do
- pager.add("")
- match.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- pager.render
- end
-
- fun props_fulldoc(pager: Pager, raw_mprops: List[MProperty]) do
- # group by module
- var cats = new HashMap[MModule, Array[MProperty]]
- for mprop in raw_mprops do
- if mprop isa MAttribute then continue
- var key = mprop.intro.mclassdef.mmodule
- if not cats.has_key(key) then cats[key] = new Array[MProperty]
- cats[key].add(mprop)
- end
- #sort groups
- var sorter = new MEntityNameSorter
- var sorted = new Array[MModule]
- sorted.add_all(cats.keys)
- sorter.sort(sorted)
- # display
- for mmodule in sorted do
- var mprops = cats[mmodule]
- pager.add("# matches in module {mmodule.namespace.bold}")
- sorter.sort(mprops)
- for mprop in mprops do
-
- end
- pager.add_rule
- end
- end
-end
-
-private class Pager
- var content = new FlatBuffer
- var indent = 0
- fun add(text: String) do
- add_indent
- addn("{text}\n")
- end
- fun add_indent do addn(" " * indent)
- fun addn(text: String) do content.append(text.escape)
- fun add_rule do add("\n---\n")
- fun render do sys.system("echo \"{content}\" | less -r")
-end
-
-redef class MModule
- super IndexMatch
- # prototype of the module
- # module name
- private fun prototype: String do return "module {name.bold}"
-
- # namespace of the module
- # project::name
- private fun namespace: String do
- if mgroup == null or mgroup.mproject.name == self.name then
- return self.name
- else
- return "{mgroup.mproject}::{self.name}"
- end
- end
-
- redef fun preview(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- pager.add(mdoc.short_comment.green)
- end
- pager.add(prototype)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- end
-
- redef fun content(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- for comment in mdoc.content do pager.add(comment.green)
- end
- pager.add(prototype)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- pager.indent = pager.indent + 1
- var sorter = new MEntityNameSorter
- # imported modules
- var imports = new Array[MModule]
- for mmodule in in_importation.direct_greaters.to_a do
- imports.add(mmodule)
- end
- if not imports.is_empty then
- sorter.sort(imports)
- pager.add("")
- pager.add("== imported modules".bold)
- pager.indent = pager.indent + 1
- for mmodule in imports do
- pager.add("")
- mmodule.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- # mclassdefs
- var intros = new Array[MClassDef]
- var redefs = new Array[MClassDef]
- for mclassdef in mclassdefs do
- if mclassdef.is_intro then
- intros.add(mclassdef)
- else
- redefs.add(mclassdef)
- end
- end
- # introductions
- if not intros.is_empty then
- sorter.sort(intros)
- pager.add("")
- pager.add("== introduced classes".bold)
- pager.indent = pager.indent + 1
- for mclass in intros do
- pager.add("")
- mclass.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- # refinements
- if not redefs.is_empty then
- sorter.sort(redefs)
- pager.add("")
- pager.add("== refined classes".bold)
- pager.indent = pager.indent + 1
- for mclass in redefs do
- pager.add("")
- mclass.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- pager.indent = pager.indent - 1
- end
-end
+ var doc = new DocModel(mainmodule.model, mainmodule)
-redef class MClass
- super IndexMatch
- # return the generic signature of the class
- # [E, F]
- private fun signature: String do
- var res = new FlatBuffer
- if arity > 0 then
- res.append("[")
- for i in [0..mparameters.length[ do
- res.append(mparameters[i].name)
- if i < mparameters.length - 1 then res.append(", ")
- end
- res.append("]")
- end
- return res.to_s
- end
+ var phases = [
+ new ExtractionPhase(toolcontext, doc),
+ new MakePagePhase(toolcontext, doc),
+ new ConcernsPhase(toolcontext, doc),
+ new StructurePhase(toolcontext, doc): DocPhase]
- # return the prototype of the class
- # class name is displayed with colors depending on visibility
- # abstract interface Foo[E]
- private fun prototype: String do
- var res = new FlatBuffer
- res.append("{kind} ")
- if visibility.to_s == "public" then res.append("{name}{signature}".bold.green)
- if visibility.to_s == "private" then res.append("{name}{signature}".bold.red)
- if visibility.to_s == "protected" then res.append("{name}{signature}".bold.yellow)
- return res.to_s
- end
-
- private fun namespace: String do
- return "{intro_mmodule.namespace}::{name}"
- end
-
- redef fun preview(index, pager) do
- intro.preview(index, pager)
- end
-
- redef fun content(index, pager) do
- # intro comment
- var sorter = new MEntityNameSorter
- var mdoc = intro.mdoc
- if mdoc != null then
- for comment in mdoc.content do pager.add(comment.green)
- end
- pager.add(intro.to_console)
- pager.add("{intro.namespace}".bold.gray + " (lines {intro.location.lines})".gray)
- pager.indent = pager.indent + 1
- # parents
- var supers = self.in_hierarchy(index.mainmodule).direct_greaters.to_a
- if not supers.is_empty then
- sorter.sort(supers)
- pager.add("")
- pager.add("== supers".bold)
- pager.indent = pager.indent + 1
- for mclass in supers do
- pager.add("")
- mclass.preview(index, pager)
- end
- pager.indent = pager.indent - 1
+ for phase in phases do
+ toolcontext.info("# {phase.class_name}", 1)
+ phase.apply
end
- # formal types
- if not self.parameter_types.is_empty then
- pager.add("")
- pager.add("== formal types".bold)
- pager.indent = pager.indent + 1
- for ft, bound in self.parameter_types do
- pager.add("")
- pager.add("{ft.to_s.bold.green}: {bound.to_console}")
- end
- pager.indent = pager.indent - 1
- end
- # intro mproperties
- var mpropdefs = intro.mpropdefs
- index.mainmodule.linearize_mpropdefs(mpropdefs)
- for cat in intro.cats2mpropdefs.keys do
- var defs = intro.cats2mpropdefs[cat].to_a
- if defs.is_empty then continue
- sorter.sort(defs)
- pager.add("")
- pager.add("== {cat}".bold)
- pager.indent = pager.indent + 1
- for mpropdef in defs do
- pager.add("")
- mpropdef.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- # refinements
- if not self.mclassdefs.is_empty then
- pager.add("")
- pager.add("== refinements".bold)
- var mclassdefs = self.mclassdefs
- index.mainmodule.linearize_mclassdefs(mclassdefs)
- pager.indent = pager.indent + 1
- for mclassdef in mclassdefs do
- if not mclassdef.is_intro then
- pager.add("")
- mclassdef.content(index, pager)
- end
- end
- pager.indent = pager.indent - 1
- end
- pager.indent = pager.indent - 1
- end
-end
-
-redef class MClassDef
- super IndexMatch
- private fun namespace: String do
- return "{mmodule.full_name}::{mclass.name}"
- end
-
- fun to_console: String do
- var res = new FlatBuffer
- if not is_intro then res.append("redef ")
- res.append(mclass.prototype)
- return res.to_s
- end
-
- redef fun preview(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- pager.add(mdoc.short_comment.green)
- end
- pager.add(to_console)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- end
-
- redef fun content(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- for comment in mdoc.content do pager.add(comment.green)
- end
- pager.add(to_console)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- pager.indent = pager.indent + 1
- var mpropdefs = self.mpropdefs
- var sorter = new MEntityNameSorter
- index.mainmodule.linearize_mpropdefs(mpropdefs)
- for cat in cats2mpropdefs.keys do
- var defs = cats2mpropdefs[cat].to_a
- sorter.sort(defs)
- if defs.is_empty then continue
- pager.add("")
- pager.add("== {cat}".bold)
- pager.indent = pager.indent + 1
- for mpropdef in defs do
- pager.add("")
- mpropdef.preview(index, pager)
- end
- pager.indent = pager.indent - 1
- end
- pager.indent = pager.indent - 1
- end
-
- # get mpropdefs grouped by categories (vt, init, methods)
- fun cats2mpropdefs: Map[String, Set[MPropDef]] do
- var cats = new ArrayMap[String, Set[MPropDef]]
- cats["virtual types"] = new HashSet[MPropDef]
- cats["constructors"] = new HashSet[MPropDef]
- cats["methods"] = new HashSet[MPropDef]
-
- for mpropdef in mpropdefs do
- if mpropdef isa MAttributeDef then continue
- if mpropdef isa MVirtualTypeDef then cats["virtual types"].add(mpropdef)
- if mpropdef isa MMethodDef then
- if mpropdef.mproperty.is_init then
- cats["constructors"].add(mpropdef)
- else
- cats["methods"].add(mpropdef)
- end
- end
- end
- return cats
- end
-end
-
-redef class MProperty
- super IndexMatch
-
- fun to_console: String do
- if visibility.to_s == "public" then return name.green
- if visibility.to_s == "private" then return name.red
- if visibility.to_s == "protected" then return name.yellow
- return name.bold
- end
-
- redef fun preview(index, pager) do
- intro.preview(index, pager)
- end
-
- redef fun content(index, pager) do
- intro.content(index, pager)
- pager.indent = pager.indent + 1
- var mpropdefs = self.mpropdefs
- index.mainmodule.linearize_mpropdefs(mpropdefs)
- for mpropdef in mpropdefs do
- if mpropdef isa MAttributeDef then continue
- if not mpropdef.is_intro then
- pager.add("")
- mpropdef.preview(index, pager)
- end
- end
- pager.indent = pager.indent - 1
- end
-end
-
-redef class MPropDef
- super IndexMatch
-
- fun to_console: String is abstract
-
- private fun namespace: String do
- return "{mclassdef.namespace}::{mproperty.name}"
- end
-
- redef fun preview(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- pager.add(mdoc.short_comment.green)
- end
- pager.add(to_console)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- end
-
- redef fun content(index, pager) do
- var mdoc = self.mdoc
- if mdoc != null then
- for comment in mdoc.content do pager.add(comment.green)
- end
- pager.add(to_console)
- pager.add("{namespace}".bold.gray + " (lines {location.lines})".gray)
- end
-end
-
-redef class MMethodDef
- redef fun to_console do
- var res = new FlatBuffer
- if not is_intro then res.append("redef ")
- if not mproperty.is_init then res.append("fun ")
- res.append(mproperty.to_console.bold)
- if msignature != null then res.append(msignature.to_console)
- if is_abstract then res.append " is abstract"
- if is_intern then res.append " is intern"
- if is_extern then res.append " is extern"
- return res.to_s
- end
-end
-
-redef class MVirtualTypeDef
- redef fun to_console do
- var res = new FlatBuffer
- res.append("type ")
- res.append(mproperty.to_console.bold)
- res.append(": {bound.to_console}")
- return res.to_s
- end
-end
-
-redef class MAttributeDef
- redef fun to_console do
- var res = new FlatBuffer
- res.append("var ")
- res.append(mproperty.to_console.bold)
- res.append(": {static_mtype.to_console}")
- return res.to_s
- end
-end
-
-redef class MSignature
- redef fun to_console do
- var res = new FlatBuffer
- if not mparameters.is_empty then
- res.append("(")
- for i in [0..mparameters.length[ do
- res.append(mparameters[i].to_console)
- if i < mparameters.length - 1 then res.append(", ")
- end
- res.append(")")
- end
- if return_mtype != null then
- res.append(": {return_mtype.to_console}")
- end
- return res.to_s
- end
-end
-
-redef class MParameter
- fun to_console: String do
- var res = new FlatBuffer
- res.append("{name}: {mtype.to_console}")
- if is_vararg then res.append("...")
- return res.to_s
- end
-end
-
-redef class MType
- fun to_console: String do return self.to_s
-end
-
-redef class MNullableType
- redef fun to_console do return "nullable {mtype.to_console}"
-end
-
-redef class MGenericType
- redef fun to_console do
- var res = new FlatBuffer
- res.append("{mclass.name}[")
- for i in [0..arguments.length[ do
- res.append(arguments[i].to_console)
- if i < arguments.length - 1 then res.append(", ")
- end
- res.append("]")
- return res.to_s
- end
-end
-
-redef class MParameterType
- redef fun to_console do return name
-end
-
-redef class MVirtualType
- redef fun to_console do return mproperty.name
-end
-
-redef class MDoc
- private fun short_comment: String do
- return content.first
- end
-end
-
-# Redef String class to add a function to color the string
-redef class String
-
- private fun add_escape_char(escapechar: String): String do
- return "{escapechar}{self}\\033[0m"
- end
-
- private fun esc: Char do return 27.ascii
- private fun gray: String do return add_escape_char("{esc}[30m")
- private fun red: String do return add_escape_char("{esc}[31m")
- private fun green: String do return add_escape_char("{esc}[32m")
- private fun yellow: String do return add_escape_char("{esc}[33m")
- private fun blue: String do return add_escape_char("{esc}[34m")
- private fun purple: String do return add_escape_char("{esc}[35m")
- private fun cyan: String do return add_escape_char("{esc}[36m")
- private fun light_gray: String do return add_escape_char("{esc}[37m")
- private fun bold: String do return add_escape_char("{esc}[1m")
- private fun underline: String do return add_escape_char("{esc}[4m")
-
- private fun escape: String
- do
- var b = new FlatBuffer
- for c in self.chars do
- if c == '\n' then
- b.append("\\n")
- else if c == '\0' then
- b.append("\\0")
- else if c == '"' then
- b.append("\\\"")
- else if c == '\\' then
- b.append("\\\\")
- else if c == '`' then
- b.append("'")
- else if c.ascii < 32 then
- b.append("\\{c.ascii.to_base(8, false)}")
- else
- b.add(c)
- end
+ # start nitx
+ var nitx = new Nitx(toolcontext, doc)
+ var q = toolcontext.opt_query.value
+ if q != null then # shortcut prompt
+ print ""
+ nitx.do_query(q)
+ return
end
- return b.to_s
- end
-end
-
-redef class Location
- fun lines: String do
- return "{line_start}-{line_end}"
+ nitx.start
end
end
-# Create a tool context to handle options and paths
+# build toolcontext
var toolcontext = new ToolContext
-toolcontext.tooldescription = "Usage: nitx [OPTION]... <file.nit> [query]\nDisplays specific pieces of API information from Nit source files."
+var tpl = new Template
+tpl.add "Usage: nitx [OPTION]... <file.nit>... [query]\n"
+tpl.add "Displays specific pieces of API information from Nit source files."
+toolcontext.tooldescription = tpl.write_to_string
+
+# process options
toolcontext.process_options(args)
+var arguments = toolcontext.option_context.rest
-# Here we launch the nit index
-var ni = new NitIndex(toolcontext)
-ni.start
+# build model
+var model = new Model
+var mbuilder = new ModelBuilder(model, toolcontext)
+var mmodules = mbuilder.parse_full(arguments)
-# TODO seek subclasses and super classes <.<class> >.<class>
-# TODO seek subclasses and super types <:<type> >:<type>
-# TODO seek with regexp
-# TODO standardize namespaces with private option
+# process
+if mmodules.is_empty then return
+mbuilder.run_phases
+toolcontext.run_global_phases(mmodules)
end
end
-redef class TFloat
+redef class TBinNumber
redef fun parser_index: Int
do
return 101
end
end
-redef class TString
+redef class TOctNumber
redef fun parser_index: Int
do
return 102
end
end
-redef class TStartString
+redef class TFloat
redef fun parser_index: Int
do
return 103
end
end
-redef class TMidString
+redef class TString
redef fun parser_index: Int
do
return 104
end
end
-redef class TEndString
+redef class TStartString
redef fun parser_index: Int
do
return 105
end
end
-redef class TChar
+redef class TMidString
redef fun parser_index: Int
do
return 106
end
end
-redef class TBadString
+redef class TEndString
redef fun parser_index: Int
do
return 107
end
end
-redef class TBadChar
+redef class TChar
redef fun parser_index: Int
do
return 108
end
end
-redef class TExternCodeSegment
+redef class TBadString
redef fun parser_index: Int
do
return 109
end
end
+redef class TBadChar
+ redef fun parser_index: Int
+ do
+ return 110
+ end
+
+ init init_tk(loc: Location)
+ do
+ _location = loc
+ end
+end
+
+redef class TExternCodeSegment
+ redef fun parser_index: Int
+ do
+ return 111
+ end
+
+ init init_tk(loc: Location)
+ do
+ _location = loc
+ end
+end
+
redef class EOF
redef fun parser_index: Int
do
- return 110
+ return 112
end
end
return new THexNumber.init_tk(location)
end
if accept_token == 102 then
- return new TFloat.init_tk(location)
+ return new TBinNumber.init_tk(location)
end
if accept_token == 103 then
- return new TString.init_tk(location)
+ return new TOctNumber.init_tk(location)
end
if accept_token == 104 then
- return new TStartString.init_tk(location)
+ return new TFloat.init_tk(location)
end
if accept_token == 105 then
- return new TMidString.init_tk(location)
+ return new TString.init_tk(location)
end
if accept_token == 106 then
- return new TEndString.init_tk(location)
+ return new TStartString.init_tk(location)
end
if accept_token == 107 then
- return new TChar.init_tk(location)
+ return new TMidString.init_tk(location)
end
if accept_token == 108 then
- return new TBadString.init_tk(location)
+ return new TEndString.init_tk(location)
end
if accept_token == 109 then
- return new TBadChar.init_tk(location)
+ return new TChar.init_tk(location)
end
if accept_token == 110 then
+ return new TBadString.init_tk(location)
+ end
+ if accept_token == 111 then
+ return new TBadChar.init_tk(location)
+ end
+ if accept_token == 112 then
return new TExternCodeSegment.init_tk(location)
end
abort # unknown token index `accept_token`
lowercase = ['a' .. 'z'];
uppercase = ['A' .. 'Z'];
digit = ['0' .. '9'];
-hexdigit = ['0'..'9'] | ['a'..'f'] | ['A'..'F'];
+hexdigit = ['0'..'9'] | ['a'..'f'] | ['A'..'F'] | '_';
+bindigit = '0' | '1' | '_';
+octdigit = ['0' .. '7'] | '_';
letter = lowercase | uppercase | digit | '_';
tab = 9;
number = digit+;
hex_number = ('0x' | '0X') hexdigit+;
+bin_number = ('0b' | '0B') bindigit+;
+oct_number = ('0o' | '0O') octdigit+;
float = digit* '.' digit+;
string = '"' str_body '"' | '"' '"' '"' long_str_body lsend1 | ''' ''' ''' long_sstr_body ''' ''' ''';
start_string = '"' str_body '{' | '"' '"' '"' long_str_body lsend2;
| {null} kwnull annotations_o {-> New expr.null(kwnull, annotations_o.annotations)}
| {int} number annotations_o {-> New expr.dec_int(number, annotations_o.annotations)}
| {hex_int} hex_number annotations_o {-> New expr.hex_int(hex_number, annotations_o.annotations)}
+ | {bin_int} bin_number annotations_o {-> New expr.bin_int(bin_number, annotations_o.annotations)}
+ | {oct_int} oct_number annotations_o {-> New expr.oct_int(oct_number, annotations_o.annotations)}
| {float} float annotations_o {-> New expr.float(float, annotations_o.annotations)}
| {char} char annotations_o {-> New expr.char(char, annotations_o.annotations)}
| {string} string annotations_o {-> New expr.string(string, annotations_o.annotations)}
| {null} kwnull annotations?
| {dec_int} number annotations?
| {hex_int} hex_number annotations?
+ | {bin_int} bin_number annotations?
+ | {oct_int} oct_number annotations?
| {float} float annotations?
| {char} char annotations?
| {string} string annotations?
new ReduceAction375(74),
new ReduceAction376(74),
new ReduceAction377(74),
+ new ReduceAction378(74),
+ new ReduceAction379(74),
new ReduceAction159(74),
new ReduceAction159(74),
- new ReduceAction380(74),
- new ReduceAction381(74),
new ReduceAction382(74),
- new ReduceAction383(75),
- new ReduceAction383(75),
- new ReduceAction385(76),
- new ReduceAction386(77),
- new ReduceAction387(78),
- new ReduceAction388(78),
- new ReduceAction386(79),
- new ReduceAction390(80),
- new ReduceAction272(80),
+ new ReduceAction383(74),
+ new ReduceAction384(74),
+ new ReduceAction385(75),
+ new ReduceAction385(75),
+ new ReduceAction387(76),
+ new ReduceAction388(77),
+ new ReduceAction389(78),
+ new ReduceAction390(78),
+ new ReduceAction388(79),
new ReduceAction392(80),
- new ReduceAction393(81),
- new ReduceAction394(81),
- new ReduceAction395(82),
- new ReduceAction396(82),
- new ReduceAction397(83),
- new ReduceAction395(84),
- new ReduceAction396(84),
- new ReduceAction400(85),
- new ReduceAction401(86),
- new ReduceAction402(87),
- new ReduceAction403(87),
- new ReduceAction404(88),
+ new ReduceAction272(80),
+ new ReduceAction394(80),
+ new ReduceAction395(81),
+ new ReduceAction396(81),
+ new ReduceAction397(82),
+ new ReduceAction398(82),
+ new ReduceAction399(83),
+ new ReduceAction397(84),
+ new ReduceAction398(84),
+ new ReduceAction402(85),
+ new ReduceAction403(86),
+ new ReduceAction404(87),
+ new ReduceAction405(87),
+ new ReduceAction406(88),
new ReduceAction22(88),
- new ReduceAction406(89),
- new ReduceAction407(89),
- new ReduceAction408(90),
- new ReduceAction409(90),
- new ReduceAction406(91),
- new ReduceAction407(91),
- new ReduceAction412(91),
+ new ReduceAction408(89),
+ new ReduceAction409(89),
+ new ReduceAction410(90),
+ new ReduceAction411(90),
+ new ReduceAction408(91),
+ new ReduceAction409(91),
+ new ReduceAction414(91),
new ReduceAction159(92),
- new ReduceAction414(93),
- new ReduceAction415(94),
- new ReduceAction416(94),
+ new ReduceAction416(93),
new ReduceAction417(94),
new ReduceAction418(94),
new ReduceAction419(94),
- new ReduceAction420(95),
- new ReduceAction421(95),
+ new ReduceAction420(94),
+ new ReduceAction421(94),
new ReduceAction422(95),
new ReduceAction423(95),
new ReduceAction424(95),
- new ReduceAction387(96),
- new ReduceAction388(96),
- new ReduceAction386(97),
- new ReduceAction428(98),
+ new ReduceAction425(95),
+ new ReduceAction426(95),
+ new ReduceAction389(96),
+ new ReduceAction390(96),
+ new ReduceAction388(97),
+ new ReduceAction430(98),
new ReduceAction159(98),
new ReduceAction159(98),
- new ReduceAction431(98),
- new ReduceAction432(98),
new ReduceAction433(98),
- new ReduceAction434(99),
- new ReduceAction435(99),
+ new ReduceAction434(98),
+ new ReduceAction435(98),
new ReduceAction436(99),
- new ReduceAction437(100),
- new ReduceAction438(100),
- new ReduceAction437(101),
- new ReduceAction440(101),
- new ReduceAction438(101),
+ new ReduceAction437(99),
+ new ReduceAction438(99),
+ new ReduceAction439(100),
+ new ReduceAction440(100),
+ new ReduceAction439(101),
new ReduceAction442(101),
- new ReduceAction443(102),
- new ReduceAction396(103),
- new ReduceAction445(103),
- new ReduceAction446(104),
- new ReduceAction447(105),
- new ReduceAction448(105),
- new ReduceAction449(106),
- new ReduceAction450(106),
- new ReduceAction451(107),
- new ReduceAction452(107),
+ new ReduceAction440(101),
+ new ReduceAction444(101),
+ new ReduceAction445(102),
+ new ReduceAction398(103),
+ new ReduceAction447(103),
+ new ReduceAction448(104),
+ new ReduceAction449(105),
+ new ReduceAction450(105),
+ new ReduceAction451(106),
+ new ReduceAction452(106),
new ReduceAction453(107),
new ReduceAction454(107),
- new ReduceAction455(108),
- new ReduceAction456(108),
+ new ReduceAction455(107),
+ new ReduceAction456(107),
new ReduceAction457(108),
+ new ReduceAction458(108),
+ new ReduceAction459(108),
new ReduceAction22(108),
- new ReduceAction459(109),
- new ReduceAction460(109),
new ReduceAction461(109),
- new ReduceAction460(109),
- new ReduceAction463(110),
- new ReduceAction464(110),
+ new ReduceAction462(109),
+ new ReduceAction463(109),
+ new ReduceAction462(109),
new ReduceAction465(110),
- new ReduceAction464(110),
- new ReduceAction467(111),
- new ReduceAction468(112),
+ new ReduceAction466(110),
+ new ReduceAction467(110),
+ new ReduceAction466(110),
+ new ReduceAction469(111),
+ new ReduceAction470(112),
new ReduceAction22(113),
- new ReduceAction470(113),
- new ReduceAction471(114),
- new ReduceAction471(114),
- new ReduceAction471(114),
- new ReduceAction474(115),
- new ReduceAction475(115),
+ new ReduceAction472(113),
+ new ReduceAction473(114),
+ new ReduceAction473(114),
+ new ReduceAction473(114),
+ new ReduceAction476(115),
+ new ReduceAction477(115),
new ReduceAction23(115),
new ReduceAction23(115),
- new ReduceAction478(115),
- new ReduceAction478(115),
new ReduceAction480(115),
- new ReduceAction481(115),
- new ReduceAction482(115),
+ new ReduceAction480(115),
new ReduceAction482(115),
+ new ReduceAction483(115),
new ReduceAction484(115),
+ new ReduceAction484(115),
+ new ReduceAction486(115),
new ReduceAction22(116),
- new ReduceAction486(116),
- new ReduceAction487(117),
- new ReduceAction471(117),
- new ReduceAction471(118),
- new ReduceAction490(118),
+ new ReduceAction488(116),
+ new ReduceAction489(117),
+ new ReduceAction473(117),
+ new ReduceAction473(118),
+ new ReduceAction492(118),
new ReduceAction48(119),
new ReduceAction49(119),
new ReduceAction50(119),
new ReduceAction105(121),
new ReduceAction106(121),
new ReduceAction107(121),
- new ReduceAction463(122),
- new ReduceAction464(122),
new ReduceAction465(122),
- new ReduceAction464(122),
+ new ReduceAction466(122),
+ new ReduceAction467(122),
+ new ReduceAction466(122),
new ReduceAction146(123),
new ReduceAction147(123),
new ReduceAction159(124),
new ReduceAction375(139),
new ReduceAction376(139),
new ReduceAction377(139),
+ new ReduceAction378(139),
+ new ReduceAction379(139),
new ReduceAction159(139),
new ReduceAction159(139),
new ReduceAction146(140),
new ReduceAction375(158),
new ReduceAction376(158),
new ReduceAction377(158),
+ new ReduceAction378(158),
+ new ReduceAction379(158),
new ReduceAction159(158),
- new ReduceAction402(159),
- new ReduceAction403(159),
- new ReduceAction404(160),
+ new ReduceAction404(159),
+ new ReduceAction405(159),
+ new ReduceAction406(160),
new ReduceAction22(160),
- new ReduceAction406(161),
- new ReduceAction406(162),
- new ReduceAction387(163),
- new ReduceAction388(163),
- new ReduceAction428(164),
+ new ReduceAction408(161),
+ new ReduceAction408(162),
+ new ReduceAction389(163),
+ new ReduceAction390(163),
+ new ReduceAction430(164),
new ReduceAction159(164),
new ReduceAction159(164),
- new ReduceAction431(164),
- new ReduceAction432(164),
+ new ReduceAction433(164),
+ new ReduceAction434(164),
new ReduceAction146(165),
new ReduceAction147(165),
new ReduceAction159(166),
new ReduceAction159(178),
new ReduceAction325(178),
new ReduceAction326(178),
- new ReduceAction853(178),
+ new ReduceAction859(178),
new ReduceAction159(179),
- new ReduceAction855(179),
- new ReduceAction856(179),
- new ReduceAction857(179),
- new ReduceAction858(179),
- new ReduceAction859(179),
+ new ReduceAction861(179),
+ new ReduceAction862(179),
+ new ReduceAction863(179),
+ new ReduceAction864(179),
+ new ReduceAction865(179),
new ReduceAction183(179),
new ReduceAction333(179),
- new ReduceAction858(179),
- new ReduceAction859(179),
+ new ReduceAction864(179),
+ new ReduceAction865(179),
new ReduceAction191(179),
new ReduceAction349(179),
- new ReduceAction866(179),
- new ReduceAction867(179),
+ new ReduceAction872(179),
+ new ReduceAction873(179),
new ReduceAction355(179),
new ReduceAction356(179),
new ReduceAction357(179),
new ReduceAction375(181),
new ReduceAction376(181),
new ReduceAction377(181),
+ new ReduceAction378(181),
+ new ReduceAction379(181),
new ReduceAction159(181),
- new ReduceAction892(182),
- new ReduceAction893(182),
+ new ReduceAction900(182),
+ new ReduceAction901(182),
new ReduceAction156(183),
new ReduceAction157(183),
new ReduceAction158(183),
new ReduceAction159(198),
new ReduceAction159(198),
new ReduceAction200(198),
- new ReduceAction434(199),
new ReduceAction436(199),
- new ReduceAction474(200),
- new ReduceAction475(200),
+ new ReduceAction438(199),
+ new ReduceAction476(200),
+ new ReduceAction477(200),
new ReduceAction23(200),
- new ReduceAction1054(201),
- new ReduceAction1055(201),
- new ReduceAction1056(202),
- new ReduceAction1057(202),
- new ReduceAction1058(203),
- new ReduceAction1059(203),
+ new ReduceAction1062(201),
+ new ReduceAction1063(201),
+ new ReduceAction1064(202),
+ new ReduceAction1065(202),
+ new ReduceAction1066(203),
+ new ReduceAction1067(203),
new ReduceAction37(204),
- new ReduceAction1061(204),
+ new ReduceAction1069(204),
new ReduceAction45(205),
- new ReduceAction1063(205),
- new ReduceAction408(206),
- new ReduceAction1065(206),
- new ReduceAction1066(207),
- new ReduceAction1067(207),
- new ReduceAction1068(208),
- new ReduceAction1069(208),
+ new ReduceAction1071(205),
+ new ReduceAction410(206),
+ new ReduceAction1073(206),
+ new ReduceAction1074(207),
+ new ReduceAction1075(207),
+ new ReduceAction1076(208),
+ new ReduceAction1077(208),
new ReduceAction150(209),
- new ReduceAction1071(209),
- new ReduceAction387(210),
- new ReduceAction1073(210),
- new ReduceAction387(211),
- new ReduceAction1073(211),
- new ReduceAction387(212),
- new ReduceAction1073(212),
- new ReduceAction448(213),
- new ReduceAction1079(213),
- new ReduceAction408(214),
- new ReduceAction1065(214),
- new ReduceAction387(215),
- new ReduceAction1073(215),
- new ReduceAction387(216),
- new ReduceAction1073(216),
- new ReduceAction449(217),
- new ReduceAction1087(217),
- new ReduceAction1088(218),
- new ReduceAction1089(218),
- new ReduceAction471(219),
- new ReduceAction490(219)
+ new ReduceAction1079(209),
+ new ReduceAction389(210),
+ new ReduceAction1081(210),
+ new ReduceAction389(211),
+ new ReduceAction1081(211),
+ new ReduceAction389(212),
+ new ReduceAction1081(212),
+ new ReduceAction450(213),
+ new ReduceAction1087(213),
+ new ReduceAction410(214),
+ new ReduceAction1073(214),
+ new ReduceAction389(215),
+ new ReduceAction1081(215),
+ new ReduceAction389(216),
+ new ReduceAction1081(216),
+ new ReduceAction451(217),
+ new ReduceAction1095(217),
+ new ReduceAction1096(218),
+ new ReduceAction1097(218),
+ new ReduceAction473(219),
+ new ReduceAction492(219)
)
end
end
var node_list: nullable Object = null
var nodearraylist2 = p.pop
var nodearraylist1 = p.pop
+ var tbinnumbernode2 = nodearraylist1
+ assert tbinnumbernode2 isa nullable TBinNumber
+ var pannotationsnode3 = nodearraylist2
+ assert pannotationsnode3 isa nullable AAnnotations
+ var pexprnode1: nullable ABinIntExpr = new ABinIntExpr.init_abinintexpr(
+ tbinnumbernode2,
+ pannotationsnode3
+ )
+ node_list = pexprnode1
+ p.push(p.go_to(_goto), node_list)
+ end
+end
+private class ReduceAction376
+ super ReduceAction
+ redef fun action(p: Parser)
+ do
+ var node_list: nullable Object = null
+ var nodearraylist2 = p.pop
+ var nodearraylist1 = p.pop
+ var toctnumbernode2 = nodearraylist1
+ assert toctnumbernode2 isa nullable TOctNumber
+ var pannotationsnode3 = nodearraylist2
+ assert pannotationsnode3 isa nullable AAnnotations
+ var pexprnode1: nullable AOctIntExpr = new AOctIntExpr.init_aoctintexpr(
+ toctnumbernode2,
+ pannotationsnode3
+ )
+ node_list = pexprnode1
+ p.push(p.go_to(_goto), node_list)
+ end
+end
+private class ReduceAction377
+ super ReduceAction
+ redef fun action(p: Parser)
+ do
+ var node_list: nullable Object = null
+ var nodearraylist2 = p.pop
+ var nodearraylist1 = p.pop
var tfloatnode2 = nodearraylist1
assert tfloatnode2 isa nullable TFloat
var pannotationsnode3 = nodearraylist2
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction376
+private class ReduceAction378
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction377
+private class ReduceAction379
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction380
+private class ReduceAction382
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction381
+private class ReduceAction383
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction382
+private class ReduceAction384
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction383
+private class ReduceAction385
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction385
+private class ReduceAction387
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction386
+private class ReduceAction388
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction387
+private class ReduceAction389
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction388
+private class ReduceAction390
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction390
+private class ReduceAction392
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction392
+private class ReduceAction394
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction393
+private class ReduceAction395
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction394
+private class ReduceAction396
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction395
+private class ReduceAction397
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction396
+private class ReduceAction398
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction397
+private class ReduceAction399
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction400
+private class ReduceAction402
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction401
+private class ReduceAction403
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction402
+private class ReduceAction404
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction403
+private class ReduceAction405
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction404
+private class ReduceAction406
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction406
+private class ReduceAction408
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction407
+private class ReduceAction409
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction408
+private class ReduceAction410
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction409
+private class ReduceAction411
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction412
+private class ReduceAction414
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction414
+private class ReduceAction416
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction415
+private class ReduceAction417
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction416
+private class ReduceAction418
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction417
+private class ReduceAction419
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction418
+private class ReduceAction420
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction419
+private class ReduceAction421
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction420
+private class ReduceAction422
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction421
+private class ReduceAction423
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction422
+private class ReduceAction424
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction423
+private class ReduceAction425
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction424
+private class ReduceAction426
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction428
+private class ReduceAction430
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction431
+private class ReduceAction433
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction432
+private class ReduceAction434
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction433
+private class ReduceAction435
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction434
+private class ReduceAction436
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction435
+private class ReduceAction437
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction436
+private class ReduceAction438
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction437
+private class ReduceAction439
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction438
+private class ReduceAction440
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction440
+private class ReduceAction442
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction442
+private class ReduceAction444
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction443
+private class ReduceAction445
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction445
+private class ReduceAction447
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction446
+private class ReduceAction448
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction447
+private class ReduceAction449
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction448
+private class ReduceAction450
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction449
+private class ReduceAction451
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction450
+private class ReduceAction452
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction451
+private class ReduceAction453
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction452
+private class ReduceAction454
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction453
+private class ReduceAction455
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction454
+private class ReduceAction456
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction455
+private class ReduceAction457
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction456
+private class ReduceAction458
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction457
+private class ReduceAction459
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction459
+private class ReduceAction461
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction460
+private class ReduceAction462
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction461
+private class ReduceAction463
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction463
+private class ReduceAction465
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction464
+private class ReduceAction466
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction465
+private class ReduceAction467
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction467
+private class ReduceAction469
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction468
+private class ReduceAction470
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction470
+private class ReduceAction472
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction471
+private class ReduceAction473
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction474
+private class ReduceAction476
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction475
+private class ReduceAction477
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction478
+private class ReduceAction480
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction480
+private class ReduceAction482
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction481
+private class ReduceAction483
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction482
+private class ReduceAction484
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction484
+private class ReduceAction486
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction486
+private class ReduceAction488
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction487
+private class ReduceAction489
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction490
+private class ReduceAction492
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction853
+private class ReduceAction859
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction855
+private class ReduceAction861
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction856
+private class ReduceAction862
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction857
+private class ReduceAction863
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction858
+private class ReduceAction864
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction859
+private class ReduceAction865
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction866
+private class ReduceAction872
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction867
+private class ReduceAction873
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction892
+private class ReduceAction900
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction893
+private class ReduceAction901
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1054
+private class ReduceAction1062
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1055
+private class ReduceAction1063
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1056
+private class ReduceAction1064
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1057
+private class ReduceAction1065
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1058
+private class ReduceAction1066
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1059
+private class ReduceAction1067
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1061
+private class ReduceAction1069
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1063
+private class ReduceAction1071
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1065
+private class ReduceAction1073
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1066
+private class ReduceAction1074
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1067
+private class ReduceAction1075
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1068
+private class ReduceAction1076
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1069
+private class ReduceAction1077
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1071
+private class ReduceAction1079
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1073
+private class ReduceAction1081
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1079
+private class ReduceAction1087
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1087
+private class ReduceAction1095
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1088
+private class ReduceAction1096
super ReduceAction
redef fun action(p: Parser)
do
p.push(p.go_to(_goto), node_list)
end
end
-private class ReduceAction1089
+private class ReduceAction1097
super ReduceAction
redef fun action(p: Parser)
do
class THexNumber
super Token
end
+class TBinNumber
+ super Token
+end
+class TOctNumber
+ super Token
+end
class TFloat
super Token
end
var n_hex_number: THexNumber is writable, noinit
var n_annotations: nullable AAnnotations = null is writable
end
+class ABinIntExpr
+ super AExpr
+ var n_bin_number: TBinNumber is writable, noinit
+ var n_annotations: nullable AAnnotations = null is writable
+end
+class AOctIntExpr
+ super AExpr
+ var n_oct_number: TOctNumber is writable, noinit
+ var n_annotations: nullable AAnnotations = null is writable
+end
class AFloatExpr
super AExpr
var n_float: TFloat is writable, noinit
super TokenLiteral
end
+# A literal binary integer
+class TBinNumber
+ super TokenLiteral
+end
+
+# A literal octal integer
+class TOctNumber
+ super TokenLiteral
+end
+
# A literal floating point number
class TFloat
super TokenLiteral
var n_hex_number: THexNumber is writable, noinit
end
+# An integer literal in binary format
+class ABinIntExpr
+ super AIntExpr
+
+ # The binary token
+ var n_bin_number: TBinNumber is writable, noinit
+end
+
+# An integer literal in octal format
+class AOctIntExpr
+ super AIntExpr
+
+ # The octal token
+ var n_oct_number: TOctNumber is writable, noinit
+end
+
# A float literal
class AFloatExpr
super AExpr
v.enter_visit(_n_annotations)
end
end
+redef class ABinIntExpr
+ init init_abinintexpr (
+ n_bin_number: nullable TBinNumber,
+ n_annotations: nullable AAnnotations
+ )
+ do
+ _n_bin_number = n_bin_number.as(not null)
+ n_bin_number.parent = self
+ _n_annotations = n_annotations
+ if n_annotations != null then n_annotations.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_bin_number == old_child then
+ n_bin_number = new_child.as(TBinNumber)
+ return
+ end
+ if _n_annotations == old_child then
+ n_annotations = new_child.as(nullable AAnnotations)
+ return
+ end
+ end
+
+ redef fun n_bin_number=(node)
+ do
+ _n_bin_number = node
+ node.parent = self
+ end
+ redef fun n_annotations=(node)
+ do
+ _n_annotations = node
+ if node != null then node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_bin_number)
+ v.enter_visit(_n_annotations)
+ end
+end
+redef class AOctIntExpr
+ init init_aoctintexpr (
+ n_oct_number: nullable TOctNumber,
+ n_annotations: nullable AAnnotations
+ )
+ do
+ _n_oct_number = n_oct_number.as(not null)
+ n_oct_number.parent = self
+ _n_annotations = n_annotations
+ if n_annotations != null then n_annotations.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_oct_number == old_child then
+ n_oct_number = new_child.as(TOctNumber)
+ return
+ end
+ if _n_annotations == old_child then
+ n_annotations = new_child.as(nullable AAnnotations)
+ return
+ end
+ end
+
+ redef fun n_oct_number=(node)
+ do
+ _n_oct_number = node
+ node.parent = self
+ end
+ redef fun n_annotations=(node)
+ do
+ _n_annotations = node
+ if node != null then node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_oct_number)
+ v.enter_visit(_n_annotations)
+ end
+end
redef class AFloatExpr
init init_afloatexpr (
n_float: nullable TFloat,
61, 61, 75
};
static const int lexer_goto_row20[] = {
- 4,
+ 8,
46, 46, 76,
48, 57, 20,
- 88, 88, 77,
- 120, 120, 78
+ 66, 66, 77,
+ 79, 79, 78,
+ 88, 88, 79,
+ 98, 98, 80,
+ 111, 111, 81,
+ 120, 120, 82
};
static const int lexer_goto_row21[] = {
1,
};
static const int lexer_goto_row22[] = {
1,
- 58, 58, 79
+ 58, 58, 83
};
static const int lexer_goto_row24[] = {
2,
- 60, 60, 80,
- 61, 61, 81
+ 60, 60, 84,
+ 61, 61, 85
};
static const int lexer_goto_row25[] = {
1,
- 61, 61, 82
+ 61, 61, 86
};
static const int lexer_goto_row26[] = {
2,
- 61, 61, 83,
- 62, 62, 84
+ 61, 61, 87,
+ 62, 62, 88
};
static const int lexer_goto_row28[] = {
4,
- 48, 57, 85,
- 65, 90, 86,
- 95, 95, 87,
- 97, 122, 88
+ 48, 57, 89,
+ 65, 90, 90,
+ 95, 95, 91,
+ 97, 122, 92
};
static const int lexer_goto_row31[] = {
1,
- 61, 61, 89
+ 61, 61, 93
};
static const int lexer_goto_row32[] = {
2,
- 95, 95, 90,
- 97, 122, 91
+ 95, 95, 94,
+ 97, 122, 95
};
static const int lexer_goto_row33[] = {
1,
- 123, 123, 92
+ 123, 123, 96
};
static const int lexer_goto_row34[] = {
10,
- 48, 57, 93,
- 65, 90, 94,
- 95, 95, 95,
- 97, 97, 96,
- 98, 98, 97,
- 99, 109, 96,
- 110, 110, 98,
- 111, 114, 96,
- 115, 115, 99,
- 116, 122, 96
+ 48, 57, 97,
+ 65, 90, 98,
+ 95, 95, 99,
+ 97, 97, 100,
+ 98, 98, 101,
+ 99, 109, 100,
+ 110, 110, 102,
+ 111, 114, 100,
+ 115, 115, 103,
+ 116, 122, 100
};
static const int lexer_goto_row35[] = {
4,
48, 95, -35,
- 97, 113, 96,
- 114, 114, 100,
- 115, 122, 96
+ 97, 113, 100,
+ 114, 114, 104,
+ 115, 122, 100
};
static const int lexer_goto_row36[] = {
6,
48, 95, -35,
- 97, 107, 96,
- 108, 108, 101,
- 109, 110, 96,
- 111, 111, 102,
- 112, 122, 96
+ 97, 107, 100,
+ 108, 108, 105,
+ 109, 110, 100,
+ 111, 111, 106,
+ 112, 122, 100
};
static const int lexer_goto_row37[] = {
4,
48, 95, -35,
- 97, 110, 96,
- 111, 111, 103,
- 112, 122, 96
+ 97, 110, 100,
+ 111, 111, 107,
+ 112, 122, 100
};
static const int lexer_goto_row38[] = {
7,
48, 107, -37,
- 108, 108, 104,
- 109, 109, 96,
- 110, 110, 105,
- 111, 119, 96,
- 120, 120, 106,
- 121, 122, 96
+ 108, 108, 108,
+ 109, 109, 100,
+ 110, 110, 109,
+ 111, 119, 100,
+ 120, 120, 110,
+ 121, 122, 100
};
static const int lexer_goto_row39[] = {
7,
48, 95, -35,
- 97, 97, 107,
- 98, 110, 96,
- 111, 111, 108,
- 112, 116, 96,
- 117, 117, 109,
- 118, 122, 96
+ 97, 97, 111,
+ 98, 110, 100,
+ 111, 111, 112,
+ 112, 116, 100,
+ 117, 117, 113,
+ 118, 122, 100
};
static const int lexer_goto_row40[] = {
2,
48, 95, -35,
- 97, 122, 96
+ 97, 122, 100
};
static const int lexer_goto_row41[] = {
9,
48, 95, -35,
- 97, 101, 96,
- 102, 102, 110,
- 103, 108, 96,
- 109, 109, 111,
- 110, 110, 112,
- 111, 114, 96,
- 115, 115, 113,
- 116, 122, 96
+ 97, 101, 100,
+ 102, 102, 114,
+ 103, 108, 100,
+ 109, 109, 115,
+ 110, 110, 116,
+ 111, 114, 100,
+ 115, 115, 117,
+ 116, 122, 100
};
static const int lexer_goto_row42[] = {
5,
48, 95, -35,
- 97, 97, 114,
- 98, 110, 96,
- 111, 111, 115,
- 112, 122, 96
+ 97, 97, 118,
+ 98, 110, 100,
+ 111, 111, 119,
+ 112, 122, 100
};
static const int lexer_goto_row43[] = {
3,
48, 110, -38,
- 111, 111, 116,
- 112, 122, 96
+ 111, 111, 120,
+ 112, 122, 100
};
static const int lexer_goto_row44[] = {
8,
48, 95, -35,
- 97, 100, 96,
- 101, 101, 117,
- 102, 110, 96,
- 111, 111, 118,
- 112, 116, 96,
- 117, 117, 119,
- 118, 122, 96
+ 97, 100, 100,
+ 101, 101, 121,
+ 102, 110, 100,
+ 111, 111, 122,
+ 112, 116, 100,
+ 117, 117, 123,
+ 118, 122, 100
};
static const int lexer_goto_row45[] = {
6,
48, 95, -35,
- 97, 109, 96,
- 110, 110, 120,
- 111, 113, 96,
- 114, 114, 121,
- 115, 122, 96
+ 97, 109, 100,
+ 110, 110, 124,
+ 111, 113, 100,
+ 114, 114, 125,
+ 115, 122, 100
};
static const int lexer_goto_row46[] = {
7,
48, 95, -35,
- 97, 97, 122,
- 98, 113, 96,
- 114, 114, 123,
- 115, 116, 96,
- 117, 117, 124,
- 118, 122, 96
+ 97, 97, 126,
+ 98, 113, 100,
+ 114, 114, 127,
+ 115, 116, 100,
+ 117, 117, 128,
+ 118, 122, 100
};
static const int lexer_goto_row47[] = {
3,
48, 100, -45,
- 101, 101, 125,
- 102, 122, 96
+ 101, 101, 129,
+ 102, 122, 100
};
static const int lexer_goto_row48[] = {
5,
48, 100, -45,
- 101, 101, 126,
- 102, 116, 96,
- 117, 117, 127,
- 118, 122, 96
+ 101, 101, 130,
+ 102, 116, 100,
+ 117, 117, 131,
+ 118, 122, 100
};
static const int lexer_goto_row49[] = {
8,
48, 95, -35,
- 97, 103, 96,
- 104, 104, 128,
- 105, 113, 96,
- 114, 114, 129,
- 115, 120, 96,
- 121, 121, 130,
- 122, 122, 96
+ 97, 103, 100,
+ 104, 104, 132,
+ 105, 113, 100,
+ 114, 114, 133,
+ 115, 120, 100,
+ 121, 121, 134,
+ 122, 122, 100
};
static const int lexer_goto_row50[] = {
3,
48, 109, -46,
- 110, 110, 131,
- 111, 122, 96
+ 110, 110, 135,
+ 111, 122, 100
};
static const int lexer_goto_row51[] = {
3,
48, 95, -35,
- 97, 97, 132,
- 98, 122, 96
+ 97, 97, 136,
+ 98, 122, 100
};
static const int lexer_goto_row52[] = {
4,
48, 103, -50,
- 104, 104, 133,
- 105, 105, 134,
- 106, 122, 96
+ 104, 104, 137,
+ 105, 105, 138,
+ 106, 122, 100
};
static const int lexer_goto_row53[] = {
1,
- 61, 61, 135
+ 61, 61, 139
};
static const int lexer_goto_row54[] = {
11,
- 0, 9, 136,
- 11, 12, 136,
- 14, 33, 136,
- 34, 34, 137,
- 35, 91, 136,
- 92, 92, 138,
- 93, 122, 136,
- 123, 123, 139,
- 124, 124, 136,
- 125, 125, 140,
- 126, 255, 136
+ 0, 9, 140,
+ 11, 12, 140,
+ 14, 33, 140,
+ 34, 34, 141,
+ 35, 91, 140,
+ 92, 92, 142,
+ 93, 122, 140,
+ 123, 123, 143,
+ 124, 124, 140,
+ 125, 125, 144,
+ 126, 255, 140
};
static const int lexer_goto_row58[] = {
3,
0, 33, -8,
- 34, 34, 141,
+ 34, 34, 145,
35, 255, -8
};
static const int lexer_goto_row59[] = {
1,
- 34, 34, 142
+ 34, 34, 146
};
static const int lexer_goto_row60[] = {
3,
- 0, 9, 143,
- 11, 12, 143,
- 14, 255, 143
+ 0, 9, 147,
+ 11, 12, 147,
+ 14, 255, 147
};
static const int lexer_goto_row62[] = {
1,
};
static const int lexer_goto_row64[] = {
1,
- 10, 10, 144
+ 10, 10, 148
};
static const int lexer_goto_row67[] = {
1,
- 39, 39, 145
+ 39, 39, 149
};
static const int lexer_goto_row68[] = {
1,
- 39, 39, 146
+ 39, 39, 150
};
static const int lexer_goto_row69[] = {
3,
- 0, 9, 147,
- 11, 12, 147,
- 14, 255, 147
+ 0, 9, 151,
+ 11, 12, 151,
+ 14, 255, 151
};
static const int lexer_goto_row70[] = {
1,
- 61, 61, 148
+ 61, 61, 152
};
static const int lexer_goto_row74[] = {
1,
- 46, 46, 149
+ 46, 46, 153
};
static const int lexer_goto_row75[] = {
1,
};
static const int lexer_goto_row78[] = {
3,
- 48, 57, 150,
- 65, 70, 151,
- 97, 102, 152
+ 48, 48, 154,
+ 49, 49, 155,
+ 95, 95, 156
};
static const int lexer_goto_row79[] = {
- 1,
- 48, 102, -79
+ 2,
+ 48, 55, 157,
+ 95, 95, 158
+};
+static const int lexer_goto_row80[] = {
+ 4,
+ 48, 57, 159,
+ 65, 70, 160,
+ 95, 95, 161,
+ 97, 102, 162
};
static const int lexer_goto_row81[] = {
1,
- 61, 61, 153
+ 48, 95, -79
};
static const int lexer_goto_row82[] = {
1,
- 62, 62, 154
+ 48, 95, -80
+};
+static const int lexer_goto_row83[] = {
+ 1,
+ 48, 102, -81
};
static const int lexer_goto_row85[] = {
1,
- 61, 61, 155
+ 61, 61, 163
};
static const int lexer_goto_row86[] = {
1,
+ 62, 62, 164
+};
+static const int lexer_goto_row89[] = {
+ 1,
+ 61, 61, 165
+};
+static const int lexer_goto_row90[] = {
+ 1,
48, 122, -29
};
-static const int lexer_goto_row87[] = {
+static const int lexer_goto_row91[] = {
1,
48, 122, -29
};
-static const int lexer_goto_row88[] = {
+static const int lexer_goto_row92[] = {
1,
48, 122, -29
};
-static const int lexer_goto_row89[] = {
+static const int lexer_goto_row93[] = {
1,
48, 122, -29
};
-static const int lexer_goto_row91[] = {
+static const int lexer_goto_row95[] = {
1,
- 100, 100, 156
+ 100, 100, 166
};
-static const int lexer_goto_row92[] = {
+static const int lexer_goto_row96[] = {
4,
- 48, 57, 157,
- 65, 90, 158,
- 95, 95, 159,
- 97, 122, 160
+ 48, 57, 167,
+ 65, 90, 168,
+ 95, 95, 169,
+ 97, 122, 170
};
-static const int lexer_goto_row93[] = {
+static const int lexer_goto_row97[] = {
5,
- 0, 91, 161,
- 92, 92, 162,
- 93, 95, 161,
- 96, 96, 163,
- 97, 255, 161
+ 0, 91, 171,
+ 92, 92, 172,
+ 93, 95, 171,
+ 96, 96, 173,
+ 97, 255, 171
};
-static const int lexer_goto_row94[] = {
+static const int lexer_goto_row98[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row95[] = {
+static const int lexer_goto_row99[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row96[] = {
+static const int lexer_goto_row100[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row97[] = {
+static const int lexer_goto_row101[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row98[] = {
+static const int lexer_goto_row102[] = {
5,
48, 110, -38,
- 111, 111, 164,
- 112, 114, 96,
- 115, 115, 165,
- 116, 122, 96
+ 111, 111, 174,
+ 112, 114, 100,
+ 115, 115, 175,
+ 116, 122, 100
};
-static const int lexer_goto_row99[] = {
+static const int lexer_goto_row103[] = {
4,
48, 95, -35,
- 97, 99, 96,
- 100, 100, 166,
- 101, 122, 96
+ 97, 99, 100,
+ 100, 100, 176,
+ 101, 122, 100
};
-static const int lexer_goto_row100[] = {
+static const int lexer_goto_row104[] = {
4,
48, 95, -35,
- 97, 114, 96,
- 115, 115, 167,
- 116, 122, 96
+ 97, 114, 100,
+ 115, 115, 177,
+ 116, 122, 100
};
-static const int lexer_goto_row101[] = {
+static const int lexer_goto_row105[] = {
3,
48, 100, -45,
- 101, 101, 168,
- 102, 122, 96
+ 101, 101, 178,
+ 102, 122, 100
};
-static const int lexer_goto_row102[] = {
+static const int lexer_goto_row106[] = {
3,
48, 95, -35,
- 97, 97, 169,
- 98, 122, 96
+ 97, 97, 179,
+ 98, 122, 100
};
-static const int lexer_goto_row103[] = {
+static const int lexer_goto_row107[] = {
3,
48, 109, -46,
- 110, 110, 170,
- 111, 122, 96
+ 110, 110, 180,
+ 111, 122, 100
};
-static const int lexer_goto_row104[] = {
+static const int lexer_goto_row108[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row105[] = {
+static const int lexer_goto_row109[] = {
3,
- 48, 114, -101,
- 115, 115, 171,
- 116, 122, 96
+ 48, 114, -105,
+ 115, 115, 181,
+ 116, 122, 100
};
-static const int lexer_goto_row106[] = {
+static const int lexer_goto_row110[] = {
5,
- 48, 99, -100,
- 100, 100, 172,
- 101, 116, 96,
- 117, 117, 173,
- 118, 122, 96
+ 48, 99, -104,
+ 100, 100, 182,
+ 101, 116, 100,
+ 117, 117, 183,
+ 118, 122, 100
};
-static const int lexer_goto_row107[] = {
+static const int lexer_goto_row111[] = {
4,
48, 95, -35,
- 97, 115, 96,
- 116, 116, 174,
- 117, 122, 96
+ 97, 115, 100,
+ 116, 116, 184,
+ 117, 122, 100
};
-static const int lexer_goto_row108[] = {
+static const int lexer_goto_row112[] = {
3,
48, 107, -37,
- 108, 108, 175,
- 109, 122, 96
+ 108, 108, 185,
+ 109, 122, 100
};
-static const int lexer_goto_row109[] = {
+static const int lexer_goto_row113[] = {
3,
48, 113, -36,
- 114, 114, 176,
- 115, 122, 96
+ 114, 114, 186,
+ 115, 122, 100
};
-static const int lexer_goto_row110[] = {
+static const int lexer_goto_row114[] = {
3,
48, 109, -46,
- 110, 110, 177,
- 111, 122, 96
+ 110, 110, 187,
+ 111, 122, 100
};
-static const int lexer_goto_row111[] = {
+static const int lexer_goto_row115[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row112[] = {
+static const int lexer_goto_row116[] = {
4,
48, 95, -35,
- 97, 111, 96,
- 112, 112, 178,
- 113, 122, 96
+ 97, 111, 100,
+ 112, 112, 188,
+ 113, 122, 100
};
-static const int lexer_goto_row113[] = {
+static const int lexer_goto_row117[] = {
6,
48, 95, -35,
- 97, 104, 96,
- 105, 105, 179,
- 106, 115, 96,
- 116, 116, 180,
- 117, 122, 96
+ 97, 104, 100,
+ 105, 105, 189,
+ 106, 115, 100,
+ 116, 116, 190,
+ 117, 122, 100
};
-static const int lexer_goto_row114[] = {
+static const int lexer_goto_row118[] = {
5,
48, 95, -35,
- 97, 97, 181,
- 98, 114, 96,
- 115, 115, 182,
- 116, 122, 96
+ 97, 97, 191,
+ 98, 114, 100,
+ 115, 115, 192,
+ 116, 122, 100
};
-static const int lexer_goto_row115[] = {
+static const int lexer_goto_row119[] = {
3,
48, 97, -35,
- 98, 98, 183,
- 99, 122, 96
+ 98, 98, 193,
+ 99, 122, 100
};
-static const int lexer_goto_row116[] = {
+static const int lexer_goto_row120[] = {
3,
48, 110, -38,
- 111, 111, 184,
- 112, 122, 96
+ 111, 111, 194,
+ 112, 122, 100
};
-static const int lexer_goto_row117[] = {
+static const int lexer_goto_row121[] = {
3,
- 48, 99, -100,
- 100, 100, 185,
- 101, 122, 96
+ 48, 99, -104,
+ 100, 100, 195,
+ 101, 122, 100
};
-static const int lexer_goto_row118[] = {
+static const int lexer_goto_row122[] = {
4,
48, 95, -35,
- 97, 118, 96,
- 119, 119, 186,
- 120, 122, 96
+ 97, 118, 100,
+ 119, 119, 196,
+ 120, 122, 100
};
-static const int lexer_goto_row119[] = {
+static const int lexer_goto_row123[] = {
3,
- 48, 115, -108,
- 116, 116, 187,
- 117, 122, 96
+ 48, 115, -112,
+ 116, 116, 197,
+ 117, 122, 100
};
-static const int lexer_goto_row120[] = {
+static const int lexer_goto_row124[] = {
3,
48, 107, -37,
- 108, 108, 188,
- 109, 122, 96
+ 108, 108, 198,
+ 109, 122, 100
};
-static const int lexer_goto_row121[] = {
+static const int lexer_goto_row125[] = {
4,
48, 95, -35,
- 97, 98, 96,
- 99, 99, 189,
- 100, 122, 96
+ 97, 98, 100,
+ 99, 99, 199,
+ 100, 122, 100
};
-static const int lexer_goto_row122[] = {
+static const int lexer_goto_row126[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row123[] = {
+static const int lexer_goto_row127[] = {
3,
- 48, 98, -122,
- 99, 99, 190,
- 100, 122, 96
+ 48, 98, -126,
+ 99, 99, 200,
+ 100, 122, 100
};
-static const int lexer_goto_row124[] = {
+static const int lexer_goto_row128[] = {
5,
- 48, 104, -114,
- 105, 105, 191,
- 106, 110, 96,
- 111, 111, 192,
- 112, 122, 96
+ 48, 104, -118,
+ 105, 105, 201,
+ 106, 110, 100,
+ 111, 111, 202,
+ 112, 122, 100
};
-static const int lexer_goto_row125[] = {
+static const int lexer_goto_row129[] = {
3,
48, 97, -35,
- 98, 98, 193,
- 99, 122, 96
+ 98, 98, 203,
+ 99, 122, 100
};
-static const int lexer_goto_row126[] = {
+static const int lexer_goto_row130[] = {
5,
- 48, 99, -100,
- 100, 100, 194,
- 101, 115, 96,
- 116, 116, 195,
- 117, 122, 96
+ 48, 99, -104,
+ 100, 100, 204,
+ 101, 115, 100,
+ 116, 116, 205,
+ 117, 122, 100
};
-static const int lexer_goto_row127[] = {
+static const int lexer_goto_row131[] = {
3,
48, 107, -37,
- 108, 108, 196,
- 109, 122, 96
+ 108, 108, 206,
+ 109, 122, 100
};
-static const int lexer_goto_row128[] = {
+static const int lexer_goto_row132[] = {
3,
- 48, 111, -113,
- 112, 112, 197,
- 113, 122, 96
+ 48, 111, -117,
+ 112, 112, 207,
+ 113, 122, 100
};
-static const int lexer_goto_row129[] = {
+static const int lexer_goto_row133[] = {
3,
48, 100, -45,
- 101, 101, 198,
- 102, 122, 96
+ 101, 101, 208,
+ 102, 122, 100
};
-static const int lexer_goto_row130[] = {
+static const int lexer_goto_row134[] = {
4,
48, 95, -35,
- 97, 116, 96,
- 117, 117, 199,
- 118, 122, 96
+ 97, 116, 100,
+ 117, 117, 209,
+ 118, 122, 100
};
-static const int lexer_goto_row131[] = {
+static const int lexer_goto_row135[] = {
3,
- 48, 111, -113,
- 112, 112, 200,
- 113, 122, 96
+ 48, 111, -117,
+ 112, 112, 210,
+ 113, 122, 100
};
-static const int lexer_goto_row132[] = {
+static const int lexer_goto_row136[] = {
3,
- 48, 104, -114,
- 105, 105, 201,
- 106, 122, 96
+ 48, 104, -118,
+ 105, 105, 211,
+ 106, 122, 100
};
-static const int lexer_goto_row133[] = {
+static const int lexer_goto_row137[] = {
3,
48, 113, -36,
- 114, 114, 202,
- 115, 122, 96
+ 114, 114, 212,
+ 115, 122, 100
};
-static const int lexer_goto_row134[] = {
+static const int lexer_goto_row138[] = {
3,
- 48, 104, -114,
- 105, 105, 203,
- 106, 122, 96
+ 48, 104, -118,
+ 105, 105, 213,
+ 106, 122, 100
};
-static const int lexer_goto_row135[] = {
+static const int lexer_goto_row139[] = {
3,
- 48, 115, -108,
- 116, 116, 204,
- 117, 122, 96
+ 48, 115, -112,
+ 116, 116, 214,
+ 117, 122, 100
};
-static const int lexer_goto_row137[] = {
+static const int lexer_goto_row141[] = {
2,
0, 123, -55,
- 124, 255, 136
+ 124, 255, 140
};
-static const int lexer_goto_row139[] = {
+static const int lexer_goto_row143[] = {
3,
- 0, 9, 205,
- 11, 12, 205,
- 14, 255, 205
+ 0, 9, 215,
+ 11, 12, 215,
+ 14, 255, 215
};
-static const int lexer_goto_row141[] = {
+static const int lexer_goto_row145[] = {
3,
0, 124, -55,
- 125, 125, 206,
- 126, 255, 136
-};
-static const int lexer_goto_row143[] = {
- 11,
- 0, 9, 207,
- 10, 10, 208,
- 11, 12, 207,
- 13, 13, 209,
- 14, 33, 207,
- 34, 34, 210,
- 35, 91, 207,
- 92, 92, 211,
- 93, 122, 207,
- 123, 123, 212,
- 124, 255, 207
-};
-static const int lexer_goto_row144[] = {
- 1,
- 0, 255, -59
+ 125, 125, 216,
+ 126, 255, 140
};
static const int lexer_goto_row147[] = {
- 9,
- 0, 9, 213,
- 10, 10, 214,
- 11, 12, 213,
- 13, 13, 215,
- 14, 38, 213,
- 39, 39, 216,
- 40, 91, 213,
- 92, 92, 217,
- 93, 255, 213
+ 11,
+ 0, 9, 217,
+ 10, 10, 218,
+ 11, 12, 217,
+ 13, 13, 219,
+ 14, 33, 217,
+ 34, 34, 220,
+ 35, 91, 217,
+ 92, 92, 221,
+ 93, 122, 217,
+ 123, 123, 222,
+ 124, 255, 217
};
static const int lexer_goto_row148[] = {
1,
- 39, 39, 218
+ 0, 255, -59
};
static const int lexer_goto_row151[] = {
- 1,
- 48, 102, -79
+ 9,
+ 0, 9, 223,
+ 10, 10, 224,
+ 11, 12, 223,
+ 13, 13, 225,
+ 14, 38, 223,
+ 39, 39, 226,
+ 40, 91, 223,
+ 92, 92, 227,
+ 93, 255, 223
};
static const int lexer_goto_row152[] = {
1,
- 48, 102, -79
+ 39, 39, 228
+};
+static const int lexer_goto_row155[] = {
+ 1,
+ 48, 95, -79
};
-static const int lexer_goto_row153[] = {
+static const int lexer_goto_row156[] = {
1,
- 48, 102, -79
+ 48, 95, -79
};
static const int lexer_goto_row157[] = {
1,
- 101, 101, 219
+ 48, 95, -79
};
static const int lexer_goto_row158[] = {
1,
- 48, 122, -93
+ 48, 95, -80
};
static const int lexer_goto_row159[] = {
1,
- 48, 122, -93
+ 48, 95, -80
};
static const int lexer_goto_row160[] = {
1,
- 48, 122, -93
+ 48, 102, -81
};
static const int lexer_goto_row161[] = {
1,
- 48, 122, -93
+ 48, 102, -81
};
static const int lexer_goto_row162[] = {
1,
- 0, 255, -94
+ 48, 102, -81
};
static const int lexer_goto_row163[] = {
1,
- 0, 255, 220
-};
-static const int lexer_goto_row164[] = {
- 3,
- 0, 124, 221,
- 125, 125, 222,
- 126, 255, 221
-};
-static const int lexer_goto_row165[] = {
- 3,
- 48, 113, -36,
- 114, 114, 223,
- 115, 122, 96
-};
-static const int lexer_goto_row166[] = {
- 3,
- 48, 115, -108,
- 116, 116, 224,
- 117, 122, 96
+ 48, 102, -81
};
static const int lexer_goto_row167[] = {
1,
- 48, 122, -41
+ 101, 101, 229
};
static const int lexer_goto_row168[] = {
- 3,
- 48, 100, -45,
- 101, 101, 225,
- 102, 122, 96
+ 1,
+ 48, 122, -97
};
static const int lexer_goto_row169[] = {
- 3,
- 48, 95, -35,
- 97, 97, 226,
- 98, 122, 96
+ 1,
+ 48, 122, -97
};
static const int lexer_goto_row170[] = {
- 3,
- 48, 114, -101,
- 115, 115, 227,
- 116, 122, 96
+ 1,
+ 48, 122, -97
};
static const int lexer_goto_row171[] = {
- 3,
- 48, 115, -108,
- 116, 116, 228,
- 117, 122, 96
+ 1,
+ 48, 122, -97
};
static const int lexer_goto_row172[] = {
- 3,
- 48, 100, -45,
- 101, 101, 229,
- 102, 122, 96
+ 1,
+ 0, 255, -98
};
static const int lexer_goto_row173[] = {
1,
- 48, 122, -41
+ 0, 255, 230
};
static const int lexer_goto_row174[] = {
- 4,
- 48, 95, -35,
- 97, 108, 96,
- 109, 109, 230,
- 110, 122, 96
+ 3,
+ 0, 124, 231,
+ 125, 125, 232,
+ 126, 255, 231
};
static const int lexer_goto_row175[] = {
3,
- 48, 100, -45,
- 101, 101, 231,
- 102, 122, 96
+ 48, 113, -36,
+ 114, 114, 233,
+ 115, 122, 100
};
static const int lexer_goto_row176[] = {
3,
- 48, 114, -101,
- 115, 115, 232,
- 116, 122, 96
+ 48, 115, -112,
+ 116, 116, 234,
+ 117, 122, 100
};
static const int lexer_goto_row177[] = {
1,
48, 122, -41
};
static const int lexer_goto_row178[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 100, -45,
+ 101, 101, 235,
+ 102, 122, 100
};
static const int lexer_goto_row179[] = {
- 5,
- 48, 107, -37,
- 108, 108, 233,
- 109, 110, 96,
- 111, 111, 234,
- 112, 122, 96
+ 3,
+ 48, 95, -35,
+ 97, 97, 236,
+ 98, 122, 100
};
static const int lexer_goto_row180[] = {
3,
- 48, 115, -108,
- 116, 116, 235,
- 117, 122, 96
+ 48, 114, -105,
+ 115, 115, 237,
+ 116, 122, 100
};
static const int lexer_goto_row181[] = {
- 5,
- 48, 100, -45,
- 101, 101, 236,
- 102, 113, 96,
- 114, 114, 237,
- 115, 122, 96
+ 3,
+ 48, 115, -112,
+ 116, 116, 238,
+ 117, 122, 100
};
static const int lexer_goto_row182[] = {
- 1,
- 48, 122, -41
-};
-static const int lexer_goto_row183[] = {
3,
48, 100, -45,
- 101, 101, 238,
- 102, 122, 96
+ 101, 101, 239,
+ 102, 122, 100
+};
+static const int lexer_goto_row183[] = {
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row184[] = {
- 3,
- 48, 100, -45,
- 101, 101, 239,
- 102, 122, 96
+ 4,
+ 48, 95, -35,
+ 97, 108, 100,
+ 109, 109, 240,
+ 110, 122, 100
};
static const int lexer_goto_row185[] = {
3,
- 48, 111, -113,
- 112, 112, 240,
- 113, 122, 96
+ 48, 100, -45,
+ 101, 101, 241,
+ 102, 122, 100
};
static const int lexer_goto_row186[] = {
3,
- 48, 116, -131,
- 117, 117, 241,
- 118, 122, 96
+ 48, 114, -105,
+ 115, 115, 242,
+ 116, 122, 100
};
static const int lexer_goto_row187[] = {
1,
48, 122, -41
};
static const int lexer_goto_row189[] = {
- 3,
+ 5,
48, 107, -37,
- 108, 108, 242,
- 109, 122, 96
+ 108, 108, 243,
+ 109, 110, 100,
+ 111, 111, 244,
+ 112, 122, 100
};
static const int lexer_goto_row190[] = {
3,
- 48, 100, -45,
- 101, 101, 243,
- 102, 122, 96
+ 48, 115, -112,
+ 116, 116, 245,
+ 117, 122, 100
};
static const int lexer_goto_row191[] = {
- 4,
- 48, 95, -35,
- 97, 106, 96,
- 107, 107, 244,
- 108, 122, 96
+ 5,
+ 48, 100, -45,
+ 101, 101, 246,
+ 102, 113, 100,
+ 114, 114, 247,
+ 115, 122, 100
};
static const int lexer_goto_row192[] = {
- 4,
- 48, 95, -35,
- 97, 117, 96,
- 118, 118, 245,
- 119, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row193[] = {
3,
- 48, 115, -108,
- 116, 116, 246,
- 117, 122, 96
+ 48, 100, -45,
+ 101, 101, 248,
+ 102, 122, 100
};
static const int lexer_goto_row194[] = {
3,
- 48, 107, -37,
- 108, 108, 247,
- 109, 122, 96
+ 48, 100, -45,
+ 101, 101, 249,
+ 102, 122, 100
};
static const int lexer_goto_row195[] = {
3,
- 48, 100, -45,
- 101, 101, 248,
- 102, 122, 96
+ 48, 111, -117,
+ 112, 112, 250,
+ 113, 122, 100
};
static const int lexer_goto_row196[] = {
3,
- 48, 116, -131,
- 117, 117, 249,
- 118, 122, 96
+ 48, 116, -135,
+ 117, 117, 251,
+ 118, 122, 100
};
static const int lexer_goto_row197[] = {
- 3,
- 48, 101, -42,
- 102, 102, 250,
- 103, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row198[] = {
- 3,
- 48, 100, -45,
- 101, 101, 251,
- 102, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row199[] = {
3,
- 48, 109, -46,
- 110, 110, 252,
- 111, 122, 96
+ 48, 107, -37,
+ 108, 108, 252,
+ 109, 122, 100
};
static const int lexer_goto_row200[] = {
3,
48, 100, -45,
101, 101, 253,
- 102, 122, 96
+ 102, 122, 100
};
static const int lexer_goto_row201[] = {
- 3,
- 48, 100, -45,
- 101, 101, 254,
- 102, 122, 96
+ 4,
+ 48, 95, -35,
+ 97, 106, 100,
+ 107, 107, 254,
+ 108, 122, 100
};
static const int lexer_goto_row202[] = {
- 3,
- 48, 117, -193,
+ 4,
+ 48, 95, -35,
+ 97, 117, 100,
118, 118, 255,
- 119, 122, 96
+ 119, 122, 100
};
static const int lexer_goto_row203[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 115, -112,
+ 116, 116, 256,
+ 117, 122, 100
};
static const int lexer_goto_row204[] = {
3,
48, 107, -37,
- 108, 108, 256,
- 109, 122, 96
+ 108, 108, 257,
+ 109, 122, 100
};
static const int lexer_goto_row205[] = {
3,
- 48, 103, -50,
- 104, 104, 257,
- 105, 122, 96
+ 48, 100, -45,
+ 101, 101, 258,
+ 102, 122, 100
};
static const int lexer_goto_row206[] = {
- 1,
- 0, 255, -138
+ 3,
+ 48, 116, -135,
+ 117, 117, 259,
+ 118, 122, 100
};
static const int lexer_goto_row207[] = {
- 11,
- 0, 9, 258,
- 10, 10, 259,
- 11, 12, 258,
- 13, 13, 260,
- 14, 33, 258,
- 34, 34, 261,
- 35, 91, 258,
- 92, 92, 262,
- 93, 122, 258,
- 123, 123, 263,
- 124, 255, 258
+ 3,
+ 48, 101, -42,
+ 102, 102, 260,
+ 103, 122, 100
};
static const int lexer_goto_row208[] = {
- 1,
- 0, 255, -144
+ 3,
+ 48, 100, -45,
+ 101, 101, 261,
+ 102, 122, 100
};
static const int lexer_goto_row209[] = {
- 1,
- 0, 255, -144
+ 3,
+ 48, 109, -46,
+ 110, 110, 262,
+ 111, 122, 100
};
static const int lexer_goto_row210[] = {
- 1,
- 0, 255, -144
+ 3,
+ 48, 100, -45,
+ 101, 101, 263,
+ 102, 122, 100
};
static const int lexer_goto_row211[] = {
- 5,
- 0, 33, -144,
- 34, 34, 264,
- 35, 122, -144,
- 123, 123, 265,
- 124, 255, 207
+ 3,
+ 48, 100, -45,
+ 101, 101, 264,
+ 102, 122, 100
};
static const int lexer_goto_row212[] = {
3,
- 0, 9, 266,
- 11, 12, 266,
- 14, 255, 266
+ 48, 117, -203,
+ 118, 118, 265,
+ 119, 122, 100
};
static const int lexer_goto_row213[] = {
- 5,
- 0, 33, -144,
- 34, 34, 267,
- 35, 122, -144,
- 123, 123, 268,
- 124, 255, 207
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row214[] = {
- 1,
- 0, 255, -148
+ 3,
+ 48, 107, -37,
+ 108, 108, 266,
+ 109, 122, 100
};
static const int lexer_goto_row215[] = {
- 1,
- 0, 255, -148
+ 3,
+ 48, 103, -50,
+ 104, 104, 267,
+ 105, 122, 100
};
static const int lexer_goto_row216[] = {
1,
- 0, 255, -148
+ 0, 255, -142
};
static const int lexer_goto_row217[] = {
- 9,
- 0, 9, 269,
- 10, 10, 270,
- 11, 12, 269,
- 13, 13, 271,
- 14, 38, 269,
- 39, 39, 272,
- 40, 91, 269,
- 92, 92, 273,
- 93, 255, 269
+ 11,
+ 0, 9, 268,
+ 10, 10, 269,
+ 11, 12, 268,
+ 13, 13, 270,
+ 14, 33, 268,
+ 34, 34, 271,
+ 35, 91, 268,
+ 92, 92, 272,
+ 93, 122, 268,
+ 123, 123, 273,
+ 124, 255, 268
};
static const int lexer_goto_row218[] = {
- 3,
- 0, 9, 274,
- 11, 12, 274,
- 14, 255, 274
+ 1,
+ 0, 255, -148
+};
+static const int lexer_goto_row219[] = {
+ 1,
+ 0, 255, -148
};
static const int lexer_goto_row220[] = {
1,
- 98, 98, 275
+ 0, 255, -148
};
static const int lexer_goto_row221[] = {
- 1,
- 0, 255, -94
+ 5,
+ 0, 33, -148,
+ 34, 34, 274,
+ 35, 122, -148,
+ 123, 123, 275,
+ 124, 255, 217
};
static const int lexer_goto_row222[] = {
- 1,
- 0, 255, -94
+ 3,
+ 0, 9, 276,
+ 11, 12, 276,
+ 14, 255, 276
+};
+static const int lexer_goto_row223[] = {
+ 5,
+ 0, 33, -148,
+ 34, 34, 277,
+ 35, 122, -148,
+ 123, 123, 278,
+ 124, 255, 217
};
static const int lexer_goto_row224[] = {
- 3,
- 48, 115, -108,
- 116, 116, 276,
- 117, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row225[] = {
- 3,
- 48, 113, -36,
- 114, 114, 277,
- 115, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row226[] = {
- 3,
- 48, 113, -36,
- 114, 114, 278,
- 115, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row227[] = {
- 3,
- 48, 106, -192,
- 107, 107, 279,
- 108, 122, 96
+ 9,
+ 0, 9, 279,
+ 10, 10, 280,
+ 11, 12, 279,
+ 13, 13, 281,
+ 14, 38, 279,
+ 39, 39, 282,
+ 40, 91, 279,
+ 92, 92, 283,
+ 93, 255, 279
};
static const int lexer_goto_row228[] = {
3,
- 48, 114, -101,
- 115, 115, 280,
- 116, 122, 96
-};
-static const int lexer_goto_row229[] = {
- 3,
- 48, 104, -114,
- 105, 105, 281,
- 106, 122, 96
+ 0, 9, 284,
+ 11, 12, 284,
+ 14, 255, 284
};
static const int lexer_goto_row230[] = {
1,
- 48, 122, -41
+ 98, 98, 285
};
static const int lexer_goto_row231[] = {
1,
- 48, 122, -41
+ 0, 255, -98
};
static const int lexer_goto_row232[] = {
- 3,
- 48, 113, -36,
- 114, 114, 282,
- 115, 122, 96
-};
-static const int lexer_goto_row233[] = {
- 3,
- 48, 100, -45,
- 101, 101, 283,
- 102, 122, 96
+ 1,
+ 0, 255, -98
};
static const int lexer_goto_row234[] = {
3,
- 48, 104, -114,
- 105, 105, 284,
- 106, 122, 96
+ 48, 115, -112,
+ 116, 116, 286,
+ 117, 122, 100
};
static const int lexer_goto_row235[] = {
3,
48, 113, -36,
- 114, 114, 285,
- 115, 122, 96
+ 114, 114, 287,
+ 115, 122, 100
};
static const int lexer_goto_row236[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 113, -36,
+ 114, 114, 288,
+ 115, 122, 100
};
static const int lexer_goto_row237[] = {
3,
- 48, 113, -36,
- 114, 114, 286,
- 115, 122, 96
+ 48, 106, -202,
+ 107, 107, 289,
+ 108, 122, 100
};
static const int lexer_goto_row238[] = {
3,
- 48, 116, -131,
- 117, 117, 287,
- 118, 122, 96
+ 48, 114, -105,
+ 115, 115, 290,
+ 116, 122, 100
};
static const int lexer_goto_row239[] = {
3,
- 48, 115, -108,
- 116, 116, 288,
- 117, 122, 96
+ 48, 104, -118,
+ 105, 105, 291,
+ 106, 122, 100
};
static const int lexer_goto_row240[] = {
- 3,
- 48, 107, -37,
- 108, 108, 289,
- 109, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row241[] = {
1,
};
static const int lexer_goto_row242[] = {
3,
- 48, 107, -37,
- 108, 108, 290,
- 109, 122, 96
+ 48, 113, -36,
+ 114, 114, 292,
+ 115, 122, 100
};
static const int lexer_goto_row243[] = {
3,
- 48, 95, -35,
- 97, 97, 291,
- 98, 122, 96
+ 48, 100, -45,
+ 101, 101, 293,
+ 102, 122, 100
};
static const int lexer_goto_row244[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 104, -118,
+ 105, 105, 294,
+ 106, 122, 100
};
static const int lexer_goto_row245[] = {
3,
- 48, 95, -35,
- 97, 97, 292,
- 98, 122, 96
+ 48, 113, -36,
+ 114, 114, 295,
+ 115, 122, 100
};
static const int lexer_goto_row246[] = {
- 3,
- 48, 95, -35,
- 97, 97, 293,
- 98, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row247[] = {
3,
- 48, 100, -45,
- 101, 101, 294,
- 102, 122, 96
+ 48, 113, -36,
+ 114, 114, 296,
+ 115, 122, 100
};
static const int lexer_goto_row248[] = {
3,
- 48, 104, -114,
- 105, 105, 295,
- 106, 122, 96
+ 48, 116, -135,
+ 117, 117, 297,
+ 118, 122, 100
};
static const int lexer_goto_row249[] = {
3,
- 48, 101, -42,
- 102, 102, 296,
- 103, 122, 96
+ 48, 115, -112,
+ 116, 116, 298,
+ 117, 122, 100
};
static const int lexer_goto_row250[] = {
3,
- 48, 113, -36,
- 114, 114, 297,
- 115, 122, 96
+ 48, 107, -37,
+ 108, 108, 299,
+ 109, 122, 100
};
static const int lexer_goto_row251[] = {
1,
};
static const int lexer_goto_row252[] = {
3,
- 48, 113, -36,
- 114, 114, 298,
- 115, 122, 96
+ 48, 107, -37,
+ 108, 108, 300,
+ 109, 122, 100
};
static const int lexer_goto_row253[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 95, -35,
+ 97, 97, 301,
+ 98, 122, 100
};
static const int lexer_goto_row254[] = {
1,
48, 122, -41
};
static const int lexer_goto_row255[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 95, -35,
+ 97, 97, 302,
+ 98, 122, 100
};
static const int lexer_goto_row256[] = {
3,
- 48, 100, -45,
- 101, 101, 299,
- 102, 122, 96
+ 48, 95, -35,
+ 97, 97, 303,
+ 98, 122, 100
};
static const int lexer_goto_row257[] = {
3,
48, 100, -45,
- 101, 101, 300,
- 102, 122, 96
+ 101, 101, 304,
+ 102, 122, 100
};
static const int lexer_goto_row258[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 104, -118,
+ 105, 105, 305,
+ 106, 122, 100
};
static const int lexer_goto_row259[] = {
- 1,
- 0, 255, -208
+ 3,
+ 48, 101, -42,
+ 102, 102, 306,
+ 103, 122, 100
};
static const int lexer_goto_row260[] = {
- 11,
- 0, 9, 301,
- 10, 10, 259,
- 11, 12, 301,
- 13, 13, 260,
- 14, 33, 301,
- 34, 34, 302,
- 35, 91, 301,
- 92, 92, 303,
- 93, 122, 301,
- 123, 123, 304,
- 124, 255, 301
+ 3,
+ 48, 113, -36,
+ 114, 114, 307,
+ 115, 122, 100
};
static const int lexer_goto_row261[] = {
1,
- 0, 255, -261
+ 48, 122, -41
};
static const int lexer_goto_row262[] = {
- 5,
- 0, 33, -261,
- 34, 34, 305,
- 35, 122, -261,
- 123, 123, 306,
- 124, 255, 301
+ 3,
+ 48, 113, -36,
+ 114, 114, 308,
+ 115, 122, 100
};
static const int lexer_goto_row263[] = {
- 3,
- 0, 9, 307,
- 11, 12, 307,
- 14, 255, 307
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row264[] = {
- 5,
- 0, 33, -261,
- 34, 34, 308,
- 35, 122, -261,
- 123, 123, 309,
- 124, 255, 301
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row265[] = {
- 3,
- 0, 33, -144,
- 34, 34, 310,
- 35, 255, -212
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row266[] = {
3,
- 0, 122, -214,
- 123, 123, 311,
- 124, 255, 207
+ 48, 100, -45,
+ 101, 101, 309,
+ 102, 122, 100
};
static const int lexer_goto_row267[] = {
- 1,
- 0, 255, -144
+ 3,
+ 48, 100, -45,
+ 101, 101, 310,
+ 102, 122, 100
};
static const int lexer_goto_row268[] = {
- 3,
- 0, 33, -144,
- 34, 34, 312,
- 35, 255, -212
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row269[] = {
- 3,
- 0, 122, -214,
- 123, 123, 313,
- 124, 255, 207
+ 1,
+ 0, 255, -218
};
static const int lexer_goto_row270[] = {
- 1,
- 0, 255, -148
+ 11,
+ 0, 9, 311,
+ 10, 10, 269,
+ 11, 12, 311,
+ 13, 13, 270,
+ 14, 33, 311,
+ 34, 34, 312,
+ 35, 91, 311,
+ 92, 92, 313,
+ 93, 122, 311,
+ 123, 123, 314,
+ 124, 255, 311
};
static const int lexer_goto_row271[] = {
1,
- 0, 255, -148
+ 0, 255, -271
};
static const int lexer_goto_row272[] = {
- 1,
- 0, 255, -148
+ 5,
+ 0, 33, -271,
+ 34, 34, 315,
+ 35, 122, -271,
+ 123, 123, 316,
+ 124, 255, 311
};
static const int lexer_goto_row273[] = {
- 9,
- 0, 9, 314,
- 10, 10, 315,
- 11, 12, 314,
- 13, 13, 316,
- 14, 38, 314,
- 39, 39, 317,
- 40, 91, 314,
- 92, 92, 318,
- 93, 255, 314
+ 3,
+ 0, 9, 317,
+ 11, 12, 317,
+ 14, 255, 317
};
static const int lexer_goto_row274[] = {
- 3,
- 0, 9, 319,
- 11, 12, 319,
- 14, 255, 319
+ 5,
+ 0, 33, -271,
+ 34, 34, 318,
+ 35, 122, -271,
+ 123, 123, 319,
+ 124, 255, 311
};
static const int lexer_goto_row275[] = {
- 1,
- 0, 255, -148
+ 3,
+ 0, 33, -148,
+ 34, 34, 320,
+ 35, 255, -222
};
static const int lexer_goto_row276[] = {
- 1,
- 117, 117, 320
+ 3,
+ 0, 122, -224,
+ 123, 123, 321,
+ 124, 255, 217
};
static const int lexer_goto_row277[] = {
1,
- 48, 122, -41
+ 0, 255, -148
};
static const int lexer_goto_row278[] = {
3,
- 48, 95, -35,
- 97, 97, 321,
- 98, 122, 96
+ 0, 33, -148,
+ 34, 34, 322,
+ 35, 255, -222
};
static const int lexer_goto_row279[] = {
3,
- 48, 115, -108,
- 116, 116, 322,
- 117, 122, 96
+ 0, 122, -224,
+ 123, 123, 323,
+ 124, 255, 217
};
static const int lexer_goto_row280[] = {
1,
- 48, 122, -41
+ 0, 255, -152
};
static const int lexer_goto_row281[] = {
1,
- 48, 122, -41
+ 0, 255, -152
};
static const int lexer_goto_row282[] = {
- 3,
- 48, 109, -46,
- 110, 110, 323,
- 111, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row283[] = {
- 3,
- 48, 109, -46,
- 110, 110, 324,
- 111, 122, 96
+ 9,
+ 0, 9, 324,
+ 10, 10, 325,
+ 11, 12, 324,
+ 13, 13, 326,
+ 14, 38, 324,
+ 39, 39, 327,
+ 40, 91, 324,
+ 92, 92, 328,
+ 93, 255, 324
};
static const int lexer_goto_row284[] = {
- 1,
- 48, 122, -41
+ 3,
+ 0, 9, 329,
+ 11, 12, 329,
+ 14, 255, 329
};
static const int lexer_goto_row285[] = {
- 3,
- 48, 100, -45,
- 101, 101, 325,
- 102, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row286[] = {
- 3,
- 48, 115, -108,
- 116, 116, 326,
- 117, 122, 96
+ 1,
+ 117, 117, 330
};
static const int lexer_goto_row287[] = {
- 3,
- 48, 101, -42,
- 102, 102, 327,
- 103, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row288[] = {
3,
- 48, 99, -100,
- 100, 100, 328,
- 101, 122, 96
+ 48, 95, -35,
+ 97, 97, 331,
+ 98, 122, 100
};
static const int lexer_goto_row289[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 115, -112,
+ 116, 116, 332,
+ 117, 122, 100
};
static const int lexer_goto_row290[] = {
1,
48, 122, -41
};
static const int lexer_goto_row291[] = {
- 3,
- 48, 100, -45,
- 101, 101, 329,
- 102, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row292[] = {
3,
- 48, 97, -35,
- 98, 98, 330,
- 99, 122, 96
+ 48, 109, -46,
+ 110, 110, 333,
+ 111, 122, 100
};
static const int lexer_goto_row293[] = {
- 4,
- 48, 95, -35,
- 97, 102, 96,
- 103, 103, 331,
- 104, 122, 96
+ 3,
+ 48, 109, -46,
+ 110, 110, 334,
+ 111, 122, 100
};
static const int lexer_goto_row294[] = {
- 3,
- 48, 115, -108,
- 116, 116, 332,
- 117, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row295[] = {
3,
- 48, 98, -122,
- 99, 99, 333,
- 100, 122, 96
+ 48, 100, -45,
+ 101, 101, 335,
+ 102, 122, 100
};
static const int lexer_goto_row296[] = {
3,
- 48, 98, -122,
- 99, 99, 334,
- 100, 122, 96
+ 48, 115, -112,
+ 116, 116, 336,
+ 117, 122, 100
};
static const int lexer_goto_row297[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 101, -42,
+ 102, 102, 337,
+ 103, 122, 100
};
static const int lexer_goto_row298[] = {
3,
- 48, 109, -46,
- 110, 110, 335,
- 111, 122, 96
+ 48, 99, -104,
+ 100, 100, 338,
+ 101, 122, 100
};
static const int lexer_goto_row299[] = {
1,
48, 122, -41
};
static const int lexer_goto_row300[] = {
- 3,
- 48, 113, -36,
- 114, 114, 336,
- 115, 122, 96
-};
-static const int lexer_goto_row301[] = {
1,
48, 122, -41
};
+static const int lexer_goto_row301[] = {
+ 3,
+ 48, 100, -45,
+ 101, 101, 339,
+ 102, 122, 100
+};
static const int lexer_goto_row302[] = {
- 1,
- 0, 255, -261
+ 3,
+ 48, 97, -35,
+ 98, 98, 340,
+ 99, 122, 100
};
static const int lexer_goto_row303[] = {
- 1,
- 0, 255, -263
+ 4,
+ 48, 95, -35,
+ 97, 102, 100,
+ 103, 103, 341,
+ 104, 122, 100
};
static const int lexer_goto_row304[] = {
3,
- 0, 9, 337,
- 11, 12, 337,
- 14, 255, 337
+ 48, 115, -112,
+ 116, 116, 342,
+ 117, 122, 100
};
static const int lexer_goto_row305[] = {
- 1,
- 0, 255, -265
+ 3,
+ 48, 98, -126,
+ 99, 99, 343,
+ 100, 122, 100
};
static const int lexer_goto_row306[] = {
3,
- 0, 33, -261,
- 34, 34, 338,
- 35, 255, -263
+ 48, 98, -126,
+ 99, 99, 344,
+ 100, 122, 100
};
static const int lexer_goto_row307[] = {
- 3,
- 0, 122, -265,
- 123, 123, 339,
- 124, 255, 301
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row308[] = {
- 1,
- 0, 255, -208
+ 3,
+ 48, 109, -46,
+ 110, 110, 345,
+ 111, 122, 100
};
static const int lexer_goto_row309[] = {
- 3,
- 0, 33, -261,
- 34, 34, 340,
- 35, 255, -263
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row310[] = {
3,
- 0, 122, -265,
- 123, 123, 341,
- 124, 255, 301
+ 48, 113, -36,
+ 114, 114, 346,
+ 115, 122, 100
};
static const int lexer_goto_row311[] = {
1,
- 34, 34, 342
+ 48, 122, -41
};
static const int lexer_goto_row312[] = {
1,
- 0, 255, -270
+ 0, 255, -271
};
static const int lexer_goto_row313[] = {
1,
- 0, 255, -266
+ 0, 255, -273
};
static const int lexer_goto_row314[] = {
- 1,
- 123, 123, 343
+ 3,
+ 0, 9, 347,
+ 11, 12, 347,
+ 14, 255, 347
};
static const int lexer_goto_row315[] = {
1,
- 0, 255, -148
+ 0, 255, -275
};
static const int lexer_goto_row316[] = {
- 1,
- 0, 255, -148
+ 3,
+ 0, 33, -271,
+ 34, 34, 348,
+ 35, 255, -273
};
static const int lexer_goto_row317[] = {
+ 3,
+ 0, 122, -275,
+ 123, 123, 349,
+ 124, 255, 311
+};
+static const int lexer_goto_row318[] = {
1,
- 0, 255, -148
+ 0, 255, -218
};
static const int lexer_goto_row319[] = {
3,
- 0, 9, 344,
- 11, 12, 344,
- 14, 255, 344
+ 0, 33, -271,
+ 34, 34, 350,
+ 35, 255, -273
};
static const int lexer_goto_row320[] = {
- 1,
- 0, 255, -148
+ 3,
+ 0, 122, -275,
+ 123, 123, 351,
+ 124, 255, 311
};
static const int lexer_goto_row321[] = {
1,
- 103, 103, 345
+ 34, 34, 352
};
static const int lexer_goto_row322[] = {
- 3,
- 48, 98, -122,
- 99, 99, 346,
- 100, 122, 96
+ 1,
+ 0, 255, -280
};
static const int lexer_goto_row323[] = {
1,
- 48, 122, -41
+ 0, 255, -276
};
static const int lexer_goto_row324[] = {
- 3,
- 48, 116, -131,
- 117, 117, 347,
- 118, 122, 96
+ 1,
+ 123, 123, 353
};
static const int lexer_goto_row325[] = {
1,
- 48, 122, -41
+ 0, 255, -152
};
static const int lexer_goto_row326[] = {
- 3,
- 48, 114, -101,
- 115, 115, 348,
- 116, 122, 96
+ 1,
+ 0, 255, -152
};
static const int lexer_goto_row327[] = {
1,
- 48, 122, -41
-};
-static const int lexer_goto_row328[] = {
- 3,
- 48, 95, -35,
- 97, 97, 349,
- 98, 122, 96
+ 0, 255, -152
};
static const int lexer_goto_row329[] = {
3,
- 48, 100, -45,
- 101, 101, 350,
- 102, 122, 96
+ 0, 9, 354,
+ 11, 12, 354,
+ 14, 255, 354
};
static const int lexer_goto_row330[] = {
1,
- 48, 122, -41
+ 0, 255, -152
};
static const int lexer_goto_row331[] = {
- 3,
- 48, 107, -37,
- 108, 108, 351,
- 109, 122, 96
+ 1,
+ 103, 103, 355
};
static const int lexer_goto_row332[] = {
3,
- 48, 100, -45,
- 101, 101, 352,
- 102, 122, 96
+ 48, 98, -126,
+ 99, 99, 356,
+ 100, 122, 100
};
static const int lexer_goto_row333[] = {
- 3,
- 48, 100, -45,
- 101, 101, 353,
- 102, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row334[] = {
3,
- 48, 115, -108,
- 116, 116, 354,
- 117, 122, 96
+ 48, 116, -135,
+ 117, 117, 357,
+ 118, 122, 100
};
static const int lexer_goto_row335[] = {
1,
48, 122, -41
};
static const int lexer_goto_row336[] = {
- 1,
- 48, 122, -41
+ 3,
+ 48, 114, -105,
+ 115, 115, 358,
+ 116, 122, 100
};
static const int lexer_goto_row337[] = {
- 3,
- 48, 114, -101,
- 115, 115, 355,
- 116, 122, 96
+ 1,
+ 48, 122, -41
};
static const int lexer_goto_row338[] = {
- 1,
- 0, 255, -261
+ 3,
+ 48, 95, -35,
+ 97, 97, 359,
+ 98, 122, 100
};
static const int lexer_goto_row339[] = {
- 1,
- 34, 34, 356
+ 3,
+ 48, 100, -45,
+ 101, 101, 360,
+ 102, 122, 100
};
static const int lexer_goto_row340[] = {
1,
- 0, 255, -311
+ 48, 122, -41
};
static const int lexer_goto_row341[] = {
- 1,
- 0, 255, -307
+ 3,
+ 48, 107, -37,
+ 108, 108, 361,
+ 109, 122, 100
};
static const int lexer_goto_row342[] = {
- 1,
- 123, 123, 357
+ 3,
+ 48, 100, -45,
+ 101, 101, 362,
+ 102, 122, 100
};
static const int lexer_goto_row343[] = {
- 1,
- 34, 34, 342
+ 3,
+ 48, 100, -45,
+ 101, 101, 363,
+ 102, 122, 100
};
static const int lexer_goto_row344[] = {
- 1,
- 123, 123, 343
+ 3,
+ 48, 115, -112,
+ 116, 116, 364,
+ 117, 122, 100
};
static const int lexer_goto_row345[] = {
1,
- 0, 255, -148
+ 48, 122, -41
};
static const int lexer_goto_row346[] = {
1,
- 95, 95, 358
+ 48, 122, -41
};
static const int lexer_goto_row347[] = {
3,
- 48, 115, -108,
- 116, 116, 359,
- 117, 122, 96
+ 48, 114, -105,
+ 115, 115, 365,
+ 116, 122, 100
};
static const int lexer_goto_row348[] = {
+ 1,
+ 0, 255, -271
+};
+static const int lexer_goto_row349[] = {
+ 1,
+ 34, 34, 366
+};
+static const int lexer_goto_row350[] = {
+ 1,
+ 0, 255, -321
+};
+static const int lexer_goto_row351[] = {
+ 1,
+ 0, 255, -317
+};
+static const int lexer_goto_row352[] = {
+ 1,
+ 123, 123, 367
+};
+static const int lexer_goto_row353[] = {
+ 1,
+ 34, 34, 352
+};
+static const int lexer_goto_row354[] = {
+ 1,
+ 123, 123, 353
+};
+static const int lexer_goto_row355[] = {
+ 1,
+ 0, 255, -152
+};
+static const int lexer_goto_row356[] = {
+ 1,
+ 95, 95, 368
+};
+static const int lexer_goto_row357[] = {
+ 3,
+ 48, 115, -112,
+ 116, 116, 369,
+ 117, 122, 100
+};
+static const int lexer_goto_row358[] = {
3,
48, 100, -45,
- 101, 101, 360,
- 102, 122, 96
+ 101, 101, 370,
+ 102, 122, 100
};
-static const int lexer_goto_row349[] = {
+static const int lexer_goto_row359[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row350[] = {
+static const int lexer_goto_row360[] = {
3,
- 48, 98, -122,
- 99, 99, 361,
- 100, 122, 96
+ 48, 98, -126,
+ 99, 99, 371,
+ 100, 122, 100
};
-static const int lexer_goto_row351[] = {
+static const int lexer_goto_row361[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row352[] = {
+static const int lexer_goto_row362[] = {
3,
48, 100, -45,
- 101, 101, 362,
- 102, 122, 96
+ 101, 101, 372,
+ 102, 122, 100
};
-static const int lexer_goto_row353[] = {
+static const int lexer_goto_row363[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row354[] = {
+static const int lexer_goto_row364[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row355[] = {
+static const int lexer_goto_row365[] = {
3,
48, 100, -45,
- 101, 101, 363,
- 102, 122, 96
+ 101, 101, 373,
+ 102, 122, 100
};
-static const int lexer_goto_row356[] = {
+static const int lexer_goto_row366[] = {
3,
48, 95, -35,
- 97, 97, 364,
- 98, 122, 96
+ 97, 97, 374,
+ 98, 122, 100
};
-static const int lexer_goto_row357[] = {
+static const int lexer_goto_row367[] = {
1,
- 34, 34, 356
+ 34, 34, 366
};
-static const int lexer_goto_row358[] = {
+static const int lexer_goto_row368[] = {
1,
- 123, 123, 357
+ 123, 123, 367
};
-static const int lexer_goto_row359[] = {
+static const int lexer_goto_row369[] = {
1,
- 95, 95, 365
+ 95, 95, 375
};
-static const int lexer_goto_row360[] = {
+static const int lexer_goto_row370[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row361[] = {
+static const int lexer_goto_row371[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row362[] = {
+static const int lexer_goto_row372[] = {
3,
48, 100, -45,
- 101, 101, 366,
- 102, 122, 96
+ 101, 101, 376,
+ 102, 122, 100
};
-static const int lexer_goto_row363[] = {
+static const int lexer_goto_row373[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row364[] = {
+static const int lexer_goto_row374[] = {
3,
- 48, 99, -100,
- 100, 100, 367,
- 101, 122, 96
+ 48, 99, -104,
+ 100, 100, 377,
+ 101, 122, 100
};
-static const int lexer_goto_row365[] = {
+static const int lexer_goto_row375[] = {
3,
48, 107, -37,
- 108, 108, 368,
- 109, 122, 96
+ 108, 108, 378,
+ 109, 122, 100
};
-static const int lexer_goto_row367[] = {
+static const int lexer_goto_row377[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row368[] = {
+static const int lexer_goto_row378[] = {
1,
48, 122, -41
};
-static const int lexer_goto_row369[] = {
+static const int lexer_goto_row379[] = {
1,
48, 122, -41
};
lexer_goto_row77,
lexer_goto_row78,
lexer_goto_row79,
- lexer_goto_row_null,
+ lexer_goto_row80,
lexer_goto_row81,
lexer_goto_row82,
- lexer_goto_row_null,
+ lexer_goto_row83,
lexer_goto_row_null,
lexer_goto_row85,
lexer_goto_row86,
- lexer_goto_row87,
- lexer_goto_row88,
- lexer_goto_row89,
lexer_goto_row_null,
+ lexer_goto_row_null,
+ lexer_goto_row89,
+ lexer_goto_row90,
lexer_goto_row91,
lexer_goto_row92,
lexer_goto_row93,
- lexer_goto_row94,
+ lexer_goto_row_null,
lexer_goto_row95,
lexer_goto_row96,
lexer_goto_row97,
lexer_goto_row133,
lexer_goto_row134,
lexer_goto_row135,
- lexer_goto_row_null,
+ lexer_goto_row136,
lexer_goto_row137,
- lexer_goto_row_null,
+ lexer_goto_row138,
lexer_goto_row139,
lexer_goto_row_null,
lexer_goto_row141,
lexer_goto_row_null,
lexer_goto_row143,
- lexer_goto_row144,
lexer_goto_row_null,
+ lexer_goto_row145,
lexer_goto_row_null,
lexer_goto_row147,
lexer_goto_row148,
lexer_goto_row_null,
lexer_goto_row151,
lexer_goto_row152,
- lexer_goto_row153,
- lexer_goto_row_null,
lexer_goto_row_null,
lexer_goto_row_null,
+ lexer_goto_row155,
+ lexer_goto_row156,
lexer_goto_row157,
lexer_goto_row158,
lexer_goto_row159,
lexer_goto_row161,
lexer_goto_row162,
lexer_goto_row163,
- lexer_goto_row164,
- lexer_goto_row165,
- lexer_goto_row166,
+ lexer_goto_row_null,
+ lexer_goto_row_null,
+ lexer_goto_row_null,
lexer_goto_row167,
lexer_goto_row168,
lexer_goto_row169,
lexer_goto_row216,
lexer_goto_row217,
lexer_goto_row218,
- lexer_goto_row_null,
+ lexer_goto_row219,
lexer_goto_row220,
lexer_goto_row221,
lexer_goto_row222,
- lexer_goto_row_null,
+ lexer_goto_row223,
lexer_goto_row224,
lexer_goto_row225,
lexer_goto_row226,
lexer_goto_row227,
lexer_goto_row228,
- lexer_goto_row229,
+ lexer_goto_row_null,
lexer_goto_row230,
lexer_goto_row231,
lexer_goto_row232,
- lexer_goto_row233,
+ lexer_goto_row_null,
lexer_goto_row234,
lexer_goto_row235,
lexer_goto_row236,
lexer_goto_row315,
lexer_goto_row316,
lexer_goto_row317,
- lexer_goto_row_null,
+ lexer_goto_row318,
lexer_goto_row319,
lexer_goto_row320,
lexer_goto_row321,
lexer_goto_row325,
lexer_goto_row326,
lexer_goto_row327,
- lexer_goto_row328,
+ lexer_goto_row_null,
lexer_goto_row329,
lexer_goto_row330,
lexer_goto_row331,
lexer_goto_row363,
lexer_goto_row364,
lexer_goto_row365,
- lexer_goto_row_null,
+ lexer_goto_row366,
lexer_goto_row367,
lexer_goto_row368,
- lexer_goto_row369
+ lexer_goto_row369,
+ lexer_goto_row370,
+ lexer_goto_row371,
+ lexer_goto_row372,
+ lexer_goto_row373,
+ lexer_goto_row374,
+ lexer_goto_row375,
+ lexer_goto_row_null,
+ lexer_goto_row377,
+ lexer_goto_row378,
+ lexer_goto_row379
};
const int lexer_accept_table[] = {
- -1,0,1,1,0,94,108,2,80,83,-1,53,54,77,75,57,76,74,79,100,100,58,96,87,60,90,95,97,55,56,82,-1,-1,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,81,108,84,1,86,108,103,-1,104,2,2,2,65,69,109,109,109,78,63,61,62,73,102,64,-1,-1,-1,59,89,88,85,91,92,97,97,97,97,68,-1,99,-1,98,98,98,98,98,98,47,98,98,98,16,98,98,98,98,98,98,23,98,29,15,98,98,98,98,98,98,98,31,98,98,98,98,98,98,98,98,98,98,98,98,98,67,108,106,-1,105,108,103,108,108,2,107,108,109,66,72,101,101,101,70,93,71,-1,99,99,99,99,-1,-1,-1,98,98,30,98,98,98,98,98,10,98,98,98,28,11,98,98,98,40,98,98,98,98,39,32,98,98,98,98,98,98,98,98,98,98,98,98,98,98,17,98,98,108,108,108,108,108,-1,-1,-1,108,108,108,-1,-1,107,-1,-1,-1,110,98,98,98,98,98,98,25,9,98,98,98,98,13,98,98,98,98,27,98,46,41,98,98,98,98,98,98,43,98,24,44,12,98,98,51,108,-1,-1,106,-1,105,-1,-1,108,-1,-1,108,108,108,-1,-1,108,-1,37,98,98,36,6,98,98,45,98,98,98,98,49,50,98,98,98,98,98,98,14,98,42,98,26,-1,-1,-1,-1,-1,-1,108,-1,-1,103,-1,-1,104,108,108,108,103,-1,108,-1,98,38,98,18,98,5,98,98,4,98,98,98,98,19,34,98,-1,106,-1,-1,105,103,104,108,-1,98,98,33,98,22,98,3,21,98,98,106,105,-1,7,35,98,48,98,98,52,8,20,9
+ -1,0,1,1,0,94,110,2,80,83,-1,53,54,77,75,57,76,74,79,100,100,58,96,87,60,90,95,97,55,56,82,-1,-1,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,98,81,110,84,1,86,110,105,-1,106,2,2,2,65,69,111,111,111,78,63,61,62,73,104,64,-1,-1,-1,-1,-1,-1,-1,59,89,88,85,91,92,97,97,97,97,68,-1,99,-1,98,98,98,98,98,98,47,98,98,98,16,98,98,98,98,98,98,23,98,29,15,98,98,98,98,98,98,98,31,98,98,98,98,98,98,98,98,98,98,98,98,98,67,110,108,-1,107,110,105,110,110,2,109,110,111,66,72,102,102,102,103,103,101,101,101,101,70,93,71,-1,99,99,99,99,-1,-1,-1,98,98,30,98,98,98,98,98,10,98,98,98,28,11,98,98,98,40,98,98,98,98,39,32,98,98,98,98,98,98,98,98,98,98,98,98,98,98,17,98,98,110,110,110,110,110,-1,-1,-1,110,110,110,-1,-1,109,-1,-1,-1,112,98,98,98,98,98,98,25,9,98,98,98,98,13,98,98,98,98,27,98,46,41,98,98,98,98,98,98,43,98,24,44,12,98,98,51,110,-1,-1,108,-1,107,-1,-1,110,-1,-1,110,110,110,-1,-1,110,-1,37,98,98,36,6,98,98,45,98,98,98,98,49,50,98,98,98,98,98,98,14,98,42,98,26,-1,-1,-1,-1,-1,-1,110,-1,-1,105,-1,-1,106,110,110,110,105,-1,110,-1,98,38,98,18,98,5,98,98,4,98,98,98,98,19,34,98,-1,108,-1,-1,107,105,106,110,-1,98,98,33,98,22,98,3,21,98,98,108,107,-1,7,35,98,48,98,98,52,8,20,9
};
static int parser_action_row1[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row2[] = {
1,
- -1, 1, 489
+ -1, 1, 491
};
static int parser_action_row3[] = {
1,
- -1, 1, 1088
+ -1, 1, 1096
};
static int parser_action_row4[] = {
4,
- -1, 1, 477,
+ -1, 1, 479,
0, 0, 1,
1, 0, 2,
95, 0, 3
static int parser_action_row5[] = {
2,
-1, 3, 4,
- 110, 2, -1
+ 112, 2, -1
};
static int parser_action_row6[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row7[] = {
1,
- -1, 1, 1054
+ -1, 1, 1062
};
static int parser_action_row8[] = {
1,
- -1, 1, 1058
+ -1, 1, 1066
};
static int parser_action_row9[] = {
1,
};
static int parser_action_row12[] = {
1,
- -1, 1, 1056
+ -1, 1, 1064
};
static int parser_action_row13[] = {
2,
- -1, 1, 486,
- 110, 1, 23
+ -1, 1, 488,
+ 112, 1, 23
};
static int parser_action_row14[] = {
- 33,
+ 35,
-1, 1, 30,
12, 0, 31,
13, 0, 32,
36, 0, 42,
37, 0, 43,
38, 0, 44,
- 41, 1, 458,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
54, 0, 52,
96, 0, 53,
97, 0, 54,
- 98, 1, 458,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row15[] = {
3,
-1, 3, 14,
- 28, 0, 84,
- 109, 0, 85
+ 28, 0, 86,
+ 111, 0, 87
};
static int parser_action_row16[] = {
1,
- -1, 1, 1090
+ -1, 1, 1098
};
static int parser_action_row17[] = {
4,
-1, 3, 16,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
static int parser_action_row18[] = {
1,
- -1, 1, 488
+ -1, 1, 490
};
static int parser_action_row19[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row20[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row21[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
static int parser_action_row22[] = {
7,
- -1, 1, 474,
- 0, 0, 102,
- 1, 0, 103,
- 9, 1, 1051,
- 28, 1, 1051,
- 95, 0, 104,
- 109, 1, 1051
+ -1, 1, 476,
+ 0, 0, 104,
+ 1, 0, 105,
+ 9, 1, 1059,
+ 28, 1, 1059,
+ 95, 0, 106,
+ 111, 1, 1059
};
static int parser_action_row23[] = {
7,
- -1, 1, 476,
+ -1, 1, 478,
0, 0, 1,
1, 0, 2,
- 9, 1, 1053,
- 28, 1, 1053,
- 95, 0, 105,
- 109, 1, 1053
+ 9, 1, 1061,
+ 28, 1, 1061,
+ 95, 0, 107,
+ 111, 1, 1061
};
static int parser_action_row24[] = {
1,
- -1, 1, 481
+ -1, 1, 483
};
static int parser_action_row25[] = {
4,
- -1, 1, 474,
- 0, 0, 102,
- 1, 0, 103,
- 95, 0, 104
+ -1, 1, 476,
+ 0, 0, 104,
+ 1, 0, 105,
+ 95, 0, 106
};
static int parser_action_row26[] = {
4,
- -1, 1, 476,
+ -1, 1, 478,
0, 0, 1,
1, 0, 2,
- 95, 0, 105
+ 95, 0, 107
};
static int parser_action_row27[] = {
1,
-1, 1, 1
};
static int parser_action_row28[] = {
- 33,
+ 35,
-1, 1, 30,
12, 0, 31,
13, 0, 32,
36, 0, 42,
37, 0, 43,
38, 0, 44,
- 41, 1, 458,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
54, 0, 52,
96, 0, 53,
97, 0, 54,
- 98, 1, 458,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row29[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row30[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
static int parser_action_row31[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
static int parser_action_row32[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 353,
73, 1, 353,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row33[] = {
1,
-1, 1, 31
};
static int parser_action_row34[] = {
- 34,
- -1, 1, 458,
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 157,
+ 9, 0, 161,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row35[] = {
2,
-1, 3, 34,
- 97, 0, 162
+ 97, 0, 166
};
static int parser_action_row36[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row37[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row38[] = {
- 34,
- -1, 1, 458,
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 157,
+ 9, 0, 161,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row39[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row40[] = {
- 26,
+ 28,
-1, 1, 169,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row41[] = {
2,
-1, 1, 174,
- 49, 0, 197
+ 49, 0, 201
};
static int parser_action_row42[] = {
2,
-1, 1, 171,
- 49, 0, 197
+ 49, 0, 201
};
static int parser_action_row43[] = {
1,
-1, 1, 173
};
static int parser_action_row44[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 200,
+ 97, 0, 204,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row45[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row46[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row47[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row48[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row49[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row50[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row51[] = {
2,
-1, 3, 50,
- 11, 0, 211
+ 11, 0, 215
};
static int parser_action_row52[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row53[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
static int parser_action_row54[] = {
2,
-1, 3, 53,
- 58, 0, 214
+ 58, 0, 218
};
static int parser_action_row55[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 341,
- 58, 0, 215,
- 59, 0, 216,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 220,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 341,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row56[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row57[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row58[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row59[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row60[] = {
- 1,
- -1, 1, 397
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row61[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row62[] = {
+ 1,
+ -1, 1, 399
+};
+static int parser_action_row63[] = {
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
+};
+static int parser_action_row64[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row63[] = {
+static int parser_action_row65[] = {
1,
-1, 1, 24
};
-static int parser_action_row64[] = {
+static int parser_action_row66[] = {
1,
-1, 1, 25
};
-static int parser_action_row65[] = {
+static int parser_action_row67[] = {
4,
-1, 1, 160,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row66[] = {
+static int parser_action_row68[] = {
1,
-1, 1, 167
};
-static int parser_action_row67[] = {
+static int parser_action_row69[] = {
1,
-1, 1, 168
};
-static int parser_action_row68[] = {
+static int parser_action_row70[] = {
1,
-1, 1, 176
};
-static int parser_action_row69[] = {
+static int parser_action_row71[] = {
1,
-1, 1, 177
};
-static int parser_action_row70[] = {
+static int parser_action_row72[] = {
1,
-1, 1, 179
};
-static int parser_action_row71[] = {
+static int parser_action_row73[] = {
1,
-1, 1, 178
};
-static int parser_action_row72[] = {
+static int parser_action_row74[] = {
1,
-1, 1, 180
};
-static int parser_action_row73[] = {
+static int parser_action_row75[] = {
1,
-1, 1, 181
};
-static int parser_action_row74[] = {
+static int parser_action_row76[] = {
1,
-1, 1, 182
};
-static int parser_action_row75[] = {
+static int parser_action_row77[] = {
3,
- -1, 3, 74,
- 54, 0, 244,
- 73, 0, 245
+ -1, 3, 76,
+ 54, 0, 250,
+ 73, 0, 251
};
-static int parser_action_row76[] = {
+static int parser_action_row78[] = {
1,
-1, 1, 329
};
-static int parser_action_row77[] = {
+static int parser_action_row79[] = {
1,
- -1, 1, 379
+ -1, 1, 381
};
-static int parser_action_row78[] = {
+static int parser_action_row80[] = {
1,
- -1, 1, 378
+ -1, 1, 380
};
-static int parser_action_row79[] = {
+static int parser_action_row81[] = {
3,
- -1, 3, 78,
- 104, 0, 247,
- 105, 0, 248
+ -1, 3, 80,
+ 106, 0, 253,
+ 107, 0, 254
};
-static int parser_action_row80[] = {
+static int parser_action_row82[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row81[] = {
+static int parser_action_row83[] = {
3,
- -1, 3, 80,
- 41, 0, 254,
- 98, 0, 255
+ -1, 3, 82,
+ 41, 0, 260,
+ 98, 0, 261
};
-static int parser_action_row82[] = {
+static int parser_action_row84[] = {
1,
- -1, 1, 1086
+ -1, 1, 1094
};
-static int parser_action_row83[] = {
+static int parser_action_row85[] = {
3,
- -1, 1, 455,
- 12, 0, 256,
- 97, 0, 257
+ -1, 1, 457,
+ 12, 0, 262,
+ 97, 0, 263
};
-static int parser_action_row84[] = {
+static int parser_action_row86[] = {
4,
- -1, 1, 457,
- 12, 0, 258,
+ -1, 1, 459,
+ 12, 0, 264,
96, 0, 53,
- 97, 0, 259
+ 97, 0, 265
};
-static int parser_action_row85[] = {
+static int parser_action_row87[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row86[] = {
+static int parser_action_row88[] = {
1,
-1, 1, 141
};
-static int parser_action_row87[] = {
+static int parser_action_row89[] = {
2,
- -1, 3, 86,
- 109, 0, 263
+ -1, 3, 88,
+ 111, 0, 269
};
-static int parser_action_row88[] = {
+static int parser_action_row90[] = {
1,
-1, 1, 145
};
-static int parser_action_row89[] = {
+static int parser_action_row91[] = {
1,
- -1, 1, 472
+ -1, 1, 474
};
-static int parser_action_row90[] = {
+static int parser_action_row92[] = {
1,
- -1, 1, 471
+ -1, 1, 473
};
-static int parser_action_row91[] = {
+static int parser_action_row93[] = {
1,
- -1, 1, 473
+ -1, 1, 475
};
-static int parser_action_row92[] = {
+static int parser_action_row94[] = {
1,
-1, 1, 20
};
-static int parser_action_row93[] = {
+static int parser_action_row95[] = {
1,
- -1, 1, 1055
+ -1, 1, 1063
};
-static int parser_action_row94[] = {
+static int parser_action_row96[] = {
1,
-1, 1, 2
};
-static int parser_action_row95[] = {
+static int parser_action_row97[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
-static int parser_action_row96[] = {
+static int parser_action_row98[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row97[] = {
+static int parser_action_row99[] = {
1,
-1, 1, 4
};
-static int parser_action_row98[] = {
+static int parser_action_row100[] = {
1,
- -1, 1, 1057
+ -1, 1, 1065
};
-static int parser_action_row99[] = {
- 33,
+static int parser_action_row101[] = {
+ 35,
-1, 1, 30,
12, 0, 31,
13, 0, 32,
36, 0, 42,
37, 0, 43,
38, 0, 44,
- 41, 1, 458,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
54, 0, 52,
96, 0, 53,
97, 0, 54,
- 98, 1, 458,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row100[] = {
+static int parser_action_row102[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row101[] = {
+static int parser_action_row103[] = {
1,
- -1, 1, 1059
+ -1, 1, 1067
};
-static int parser_action_row102[] = {
+static int parser_action_row104[] = {
1,
-1, 1, 8
};
-static int parser_action_row103[] = {
+static int parser_action_row105[] = {
1,
- -1, 1, 490
+ -1, 1, 492
};
-static int parser_action_row104[] = {
+static int parser_action_row106[] = {
1,
- -1, 1, 1089
+ -1, 1, 1097
};
-static int parser_action_row105[] = {
+static int parser_action_row107[] = {
4,
- -1, 1, 479,
+ -1, 1, 481,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row106[] = {
+static int parser_action_row108[] = {
4,
- -1, 1, 478,
+ -1, 1, 480,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row107[] = {
+static int parser_action_row109[] = {
1,
- -1, 1, 1091
+ -1, 1, 1099
};
-static int parser_action_row108[] = {
+static int parser_action_row110[] = {
7,
- -1, 1, 475,
- 0, 0, 102,
- 1, 0, 103,
- 9, 1, 1052,
- 28, 1, 1052,
- 95, 0, 271,
- 109, 1, 1052
+ -1, 1, 477,
+ 0, 0, 104,
+ 1, 0, 105,
+ 9, 1, 1060,
+ 28, 1, 1060,
+ 95, 0, 277,
+ 111, 1, 1060
};
-static int parser_action_row109[] = {
+static int parser_action_row111[] = {
4,
- -1, 1, 475,
- 0, 0, 102,
- 1, 0, 103,
- 95, 0, 271
+ -1, 1, 477,
+ 0, 0, 104,
+ 1, 0, 105,
+ 95, 0, 277
};
-static int parser_action_row110[] = {
+static int parser_action_row112[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row111[] = {
+static int parser_action_row113[] = {
1,
-1, 1, 3
};
-static int parser_action_row112[] = {
+static int parser_action_row114[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 1, 487,
+ 28, 1, 489,
95, 0, 3,
- 109, 1, 487,
- 110, 1, 22
+ 111, 1, 489,
+ 112, 1, 22
};
-static int parser_action_row113[] = {
+static int parser_action_row115[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row114[] = {
+static int parser_action_row116[] = {
1,
-1, 1, 5
};
-static int parser_action_row115[] = {
+static int parser_action_row117[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row116[] = {
+static int parser_action_row118[] = {
1,
-1, 1, 9
};
-static int parser_action_row117[] = {
+static int parser_action_row119[] = {
2,
- -1, 1, 768,
- 52, 0, 277
+ -1, 1, 772,
+ 52, 0, 283
};
-static int parser_action_row118[] = {
+static int parser_action_row120[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row119[] = {
+static int parser_action_row121[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row120[] = {
+static int parser_action_row122[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row121[] = {
+static int parser_action_row123[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row122[] = {
- 2,
- -1, 1, 405,
- 94, 0, 204
-};
-static int parser_action_row123[] = {
- 2,
- -1, 1, 405,
- 94, 0, 204
-};
static int parser_action_row124[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row125[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row126[] = {
- 15,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 287,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row127[] = {
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
+};
+static int parser_action_row128[] = {
+ 17,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 293,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row129[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row128[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row130[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row129[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row131[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row130[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row132[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
-};
-static int parser_action_row131[] = {
- 3,
- -1, 1, 756,
- 52, 0, 277,
- 58, 0, 215
-};
-static int parser_action_row132[] = {
- 2,
- -1, 1, 405,
- 94, 0, 204
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
static int parser_action_row133[] = {
- 2,
- -1, 1, 405,
- 94, 0, 204
+ 3,
+ -1, 1, 760,
+ 52, 0, 283,
+ 58, 0, 219
};
static int parser_action_row134[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row135[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row136[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row137[] = {
- 1,
- -1, 1, 793
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row138[] = {
- 1,
- -1, 1, 352
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row139[] = {
- 1,
- -1, 1, 193
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row140[] = {
- 3,
- -1, 3, 139,
- 41, 0, 300,
- 98, 0, 301
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
};
static int parser_action_row141[] = {
- 2,
- -1, 1, 455,
- 97, 0, 302
+ 1,
+ -1, 1, 799
};
static int parser_action_row142[] = {
1,
- -1, 1, 440
+ -1, 1, 352
};
static int parser_action_row143[] = {
- 4,
- -1, 1, 698,
- 29, 0, 303,
- 30, 0, 304,
- 32, 0, 305
+ 1,
+ -1, 1, 193
};
static int parser_action_row144[] = {
- 1,
- -1, 1, 700
+ 3,
+ -1, 3, 143,
+ 41, 0, 308,
+ 98, 0, 309
};
static int parser_action_row145[] = {
- 1,
- -1, 1, 705
+ 2,
+ -1, 1, 457,
+ 97, 0, 310
};
static int parser_action_row146[] = {
- 10,
- -1, 1, 707,
- 39, 0, 306,
- 80, 0, 307,
- 84, 0, 308,
- 85, 0, 309,
- 86, 0, 310,
- 87, 0, 311,
- 89, 0, 312,
- 90, 0, 313,
- 92, 0, 314
+ 1,
+ -1, 1, 442
};
static int parser_action_row147[] = {
- 2,
- -1, 1, 716,
- 81, 0, 315
+ 4,
+ -1, 1, 702,
+ 29, 0, 311,
+ 30, 0, 312,
+ 32, 0, 313
};
static int parser_action_row148[] = {
- 2,
- -1, 1, 718,
- 82, 0, 316
+ 1,
+ -1, 1, 704
};
static int parser_action_row149[] = {
- 3,
- -1, 1, 720,
- 88, 0, 317,
- 91, 0, 318
+ 1,
+ -1, 1, 709
};
static int parser_action_row150[] = {
- 3,
- -1, 1, 722,
- 74, 0, 319,
- 75, 0, 320
+ 10,
+ -1, 1, 711,
+ 39, 0, 314,
+ 80, 0, 315,
+ 84, 0, 316,
+ 85, 0, 317,
+ 86, 0, 318,
+ 87, 0, 319,
+ 89, 0, 320,
+ 90, 0, 321,
+ 92, 0, 322
};
static int parser_action_row151[] = {
- 4,
- -1, 1, 725,
- 76, 0, 321,
- 78, 0, 322,
- 79, 0, 323
+ 2,
+ -1, 1, 720,
+ 81, 0, 323
};
static int parser_action_row152[] = {
- 1,
- -1, 1, 728
+ 2,
+ -1, 1, 722,
+ 82, 0, 324
};
static int parser_action_row153[] = {
- 2,
- -1, 1, 732,
- 77, 0, 324
+ 3,
+ -1, 1, 724,
+ 88, 0, 325,
+ 91, 0, 326
};
static int parser_action_row154[] = {
- 1,
- -1, 1, 734
+ 3,
+ -1, 1, 726,
+ 74, 0, 327,
+ 75, 0, 328
};
static int parser_action_row155[] = {
- 3,
- -1, 1, 739,
- 54, 0, 244,
- 73, 0, 325
+ 4,
+ -1, 1, 729,
+ 76, 0, 329,
+ 78, 0, 330,
+ 79, 0, 331
};
static int parser_action_row156[] = {
1,
- -1, 1, 744
+ -1, 1, 732
};
static int parser_action_row157[] = {
+ 2,
+ -1, 1, 736,
+ 77, 0, 332
+};
+static int parser_action_row158[] = {
+ 1,
+ -1, 1, 738
+};
+static int parser_action_row159[] = {
3,
- -1, 1, 457,
+ -1, 1, 743,
+ 54, 0, 250,
+ 73, 0, 333
+};
+static int parser_action_row160[] = {
+ 1,
+ -1, 1, 748
+};
+static int parser_action_row161[] = {
+ 3,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 327
+ 97, 0, 335
};
-static int parser_action_row158[] = {
+static int parser_action_row162[] = {
2,
-1, 1, 158,
- 49, 1, 981
+ 49, 1, 989
};
-static int parser_action_row159[] = {
+static int parser_action_row163[] = {
1,
-1, 1, 257
};
-static int parser_action_row160[] = {
+static int parser_action_row164[] = {
1,
-1, 1, 159
};
-static int parser_action_row161[] = {
- 31,
- -1, 1, 458,
- 9, 0, 329,
+static int parser_action_row165[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 337,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row162[] = {
+static int parser_action_row166[] = {
2,
- -1, 3, 161,
- 49, 0, 197
+ -1, 3, 165,
+ 49, 0, 201
};
-static int parser_action_row163[] = {
+static int parser_action_row167[] = {
3,
-1, 1, 155,
- 57, 0, 333,
- 94, 0, 204
+ 57, 0, 341,
+ 94, 0, 208
};
-static int parser_action_row164[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row168[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row165[] = {
+static int parser_action_row169[] = {
3,
- -1, 1, 1051,
- 0, 0, 102,
- 1, 0, 103
+ -1, 1, 1059,
+ 0, 0, 104,
+ 1, 0, 105
};
-static int parser_action_row166[] = {
+static int parser_action_row170[] = {
3,
- -1, 1, 1053,
+ -1, 1, 1061,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row167[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row171[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row168[] = {
+static int parser_action_row172[] = {
1,
-1, 1, 268
};
-static int parser_action_row169[] = {
+static int parser_action_row173[] = {
2,
- -1, 3, 168,
- 49, 0, 197
+ -1, 3, 172,
+ 49, 0, 201
};
-static int parser_action_row170[] = {
+static int parser_action_row174[] = {
3,
- -1, 3, 169,
- 52, 0, 340,
- 97, 0, 341
+ -1, 3, 173,
+ 52, 0, 348,
+ 97, 0, 349
};
-static int parser_action_row171[] = {
+static int parser_action_row175[] = {
2,
-1, 1, 353,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row172[] = {
+static int parser_action_row176[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row173[] = {
+static int parser_action_row177[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row174[] = {
+static int parser_action_row178[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row175[] = {
+static int parser_action_row179[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row176[] = {
- 17,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row180[] = {
+ 19,
+ -1, 1, 460,
+ 12, 0, 174,
38, 0, 44,
42, 0, 45,
43, 0, 46,
52, 0, 51,
54, 0, 52,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row177[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row181[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row178[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row182[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row179[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row183[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row180[] = {
+static int parser_action_row184[] = {
3,
-1, 1, 341,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row181[] = {
+static int parser_action_row185[] = {
1,
-1, 1, 170
};
-static int parser_action_row182[] = {
+static int parser_action_row186[] = {
4,
-1, 1, 283,
- 29, 0, 354,
- 30, 0, 355,
- 32, 0, 356
+ 29, 0, 362,
+ 30, 0, 363,
+ 32, 0, 364
};
-static int parser_action_row183[] = {
+static int parser_action_row187[] = {
1,
-1, 1, 285
};
-static int parser_action_row184[] = {
+static int parser_action_row188[] = {
1,
-1, 1, 290
};
-static int parser_action_row185[] = {
+static int parser_action_row189[] = {
10,
-1, 1, 292,
- 39, 0, 357,
- 80, 0, 358,
- 84, 0, 359,
- 85, 0, 360,
- 86, 0, 361,
- 87, 0, 362,
- 89, 0, 363,
- 90, 0, 364,
- 92, 0, 365
+ 39, 0, 365,
+ 80, 0, 366,
+ 84, 0, 367,
+ 85, 0, 368,
+ 86, 0, 369,
+ 87, 0, 370,
+ 89, 0, 371,
+ 90, 0, 372,
+ 92, 0, 373
};
-static int parser_action_row186[] = {
+static int parser_action_row190[] = {
2,
-1, 1, 301,
- 81, 0, 366
+ 81, 0, 374
};
-static int parser_action_row187[] = {
+static int parser_action_row191[] = {
2,
-1, 1, 303,
- 82, 0, 367
+ 82, 0, 375
};
-static int parser_action_row188[] = {
+static int parser_action_row192[] = {
3,
-1, 1, 305,
- 88, 0, 368,
- 91, 0, 369
+ 88, 0, 376,
+ 91, 0, 377
};
-static int parser_action_row189[] = {
+static int parser_action_row193[] = {
3,
-1, 1, 307,
- 74, 0, 370,
- 75, 0, 371
+ 74, 0, 378,
+ 75, 0, 379
};
-static int parser_action_row190[] = {
+static int parser_action_row194[] = {
4,
-1, 1, 310,
- 76, 0, 372,
- 78, 0, 373,
- 79, 0, 374
+ 76, 0, 380,
+ 78, 0, 381,
+ 79, 0, 382
};
-static int parser_action_row191[] = {
+static int parser_action_row195[] = {
1,
-1, 1, 313
};
-static int parser_action_row192[] = {
+static int parser_action_row196[] = {
2,
-1, 1, 317,
- 77, 0, 375
+ 77, 0, 383
};
-static int parser_action_row193[] = {
+static int parser_action_row197[] = {
1,
-1, 1, 319
};
-static int parser_action_row194[] = {
+static int parser_action_row198[] = {
3,
-1, 1, 324,
- 54, 0, 244,
- 73, 0, 376
+ 54, 0, 250,
+ 73, 0, 384
};
-static int parser_action_row195[] = {
+static int parser_action_row199[] = {
3,
- -1, 3, 194,
- 41, 0, 378,
- 98, 0, 379
+ -1, 3, 198,
+ 41, 0, 386,
+ 98, 0, 387
};
-static int parser_action_row196[] = {
+static int parser_action_row200[] = {
2,
- -1, 1, 455,
- 97, 0, 380
+ -1, 1, 457,
+ 97, 0, 388
};
-static int parser_action_row197[] = {
+static int parser_action_row201[] = {
3,
- -1, 1, 457,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 381
+ 97, 0, 389
};
-static int parser_action_row198[] = {
+static int parser_action_row202[] = {
2,
-1, 1, 201,
- 97, 0, 383
+ 97, 0, 391
};
-static int parser_action_row199[] = {
+static int parser_action_row203[] = {
1,
-1, 1, 175
};
-static int parser_action_row200[] = {
+static int parser_action_row204[] = {
1,
-1, 1, 172
};
-static int parser_action_row201[] = {
+static int parser_action_row205[] = {
4,
-1, 1, 341,
- 52, 0, 277,
- 57, 0, 384,
- 58, 0, 215
+ 52, 0, 283,
+ 57, 0, 392,
+ 58, 0, 219
};
-static int parser_action_row202[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row206[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row203[] = {
+static int parser_action_row207[] = {
2,
-1, 1, 280,
- 24, 0, 386
+ 24, 0, 394
};
-static int parser_action_row204[] = {
+static int parser_action_row208[] = {
3,
- -1, 3, 203,
- 47, 0, 387,
- 96, 0, 388
+ -1, 3, 207,
+ 47, 0, 395,
+ 96, 0, 396
};
-static int parser_action_row205[] = {
+static int parser_action_row209[] = {
3,
-1, 1, 30,
13, 0, 32,
- 52, 0, 390
+ 52, 0, 398
};
-static int parser_action_row206[] = {
+static int parser_action_row210[] = {
1,
- -1, 1, 404
+ -1, 1, 406
};
-static int parser_action_row207[] = {
+static int parser_action_row211[] = {
1,
-1, 1, 369
};
-static int parser_action_row208[] = {
+static int parser_action_row212[] = {
1,
-1, 1, 370
};
-static int parser_action_row209[] = {
+static int parser_action_row213[] = {
1,
-1, 1, 371
};
-static int parser_action_row210[] = {
+static int parser_action_row214[] = {
1,
-1, 1, 372
};
-static int parser_action_row211[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row215[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 393,
+ 97, 0, 401,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row212[] = {
+static int parser_action_row216[] = {
3,
- -1, 3, 211,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 215,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row213[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row217[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row214[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 446,
- 27, 0, 447,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row218[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 454,
+ 27, 0, 455,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row215[] = {
+static int parser_action_row219[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row216[] = {
+static int parser_action_row220[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row217[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row221[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row218[] = {
+static int parser_action_row222[] = {
1,
-1, 1, 245
};
-static int parser_action_row219[] = {
+static int parser_action_row223[] = {
1,
-1, 1, 246
};
-static int parser_action_row220[] = {
+static int parser_action_row224[] = {
1,
-1, 1, 247
};
-static int parser_action_row221[] = {
+static int parser_action_row225[] = {
1,
-1, 1, 248
};
-static int parser_action_row222[] = {
+static int parser_action_row226[] = {
1,
-1, 1, 249
};
-static int parser_action_row223[] = {
+static int parser_action_row227[] = {
1,
-1, 1, 250
};
-static int parser_action_row224[] = {
+static int parser_action_row228[] = {
1,
-1, 1, 251
};
-static int parser_action_row225[] = {
+static int parser_action_row229[] = {
1,
-1, 1, 252
};
-static int parser_action_row226[] = {
+static int parser_action_row230[] = {
1,
-1, 1, 253
};
-static int parser_action_row227[] = {
+static int parser_action_row231[] = {
1,
-1, 1, 254
};
-static int parser_action_row228[] = {
+static int parser_action_row232[] = {
1,
-1, 1, 255
};
-static int parser_action_row229[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row233[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row230[] = {
+static int parser_action_row234[] = {
13,
-1, 1, 340,
- 59, 0, 455,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 463,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row231[] = {
+static int parser_action_row235[] = {
1,
-1, 1, 187
};
-static int parser_action_row232[] = {
+static int parser_action_row236[] = {
1,
-1, 1, 373
};
-static int parser_action_row233[] = {
+static int parser_action_row237[] = {
1,
-1, 1, 374
};
-static int parser_action_row234[] = {
+static int parser_action_row238[] = {
1,
-1, 1, 375
};
-static int parser_action_row235[] = {
+static int parser_action_row239[] = {
+ 1,
+ -1, 1, 376
+};
+static int parser_action_row240[] = {
1,
-1, 1, 377
};
-static int parser_action_row236[] = {
+static int parser_action_row241[] = {
1,
- -1, 1, 376
+ -1, 1, 379
};
-static int parser_action_row237[] = {
+static int parser_action_row242[] = {
+ 1,
+ -1, 1, 378
+};
+static int parser_action_row243[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row238[] = {
+static int parser_action_row244[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row239[] = {
+static int parser_action_row245[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row240[] = {
+static int parser_action_row246[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row241[] = {
+static int parser_action_row247[] = {
9,
- -1, 3, 240,
- 3, 0, 461,
- 4, 0, 462,
- 5, 0, 463,
- 6, 0, 464,
- 7, 0, 465,
- 8, 0, 466,
- 10, 0, 467,
- 17, 0, 468
+ -1, 3, 246,
+ 3, 0, 469,
+ 4, 0, 470,
+ 5, 0, 471,
+ 6, 0, 472,
+ 7, 0, 473,
+ 8, 0, 474,
+ 10, 0, 475,
+ 17, 0, 476
};
-static int parser_action_row242[] = {
+static int parser_action_row248[] = {
1,
- -1, 1, 1072
+ -1, 1, 1080
};
-static int parser_action_row243[] = {
- 32,
+static int parser_action_row249[] = {
+ 34,
-1, 1, 162,
12, 0, 31,
15, 0, 33,
36, 0, 42,
37, 0, 43,
38, 0, 44,
- 41, 1, 458,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
54, 0, 52,
96, 0, 53,
97, 0, 54,
- 98, 1, 458,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row244[] = {
+static int parser_action_row250[] = {
4,
-1, 1, 161,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row245[] = {
+static int parser_action_row251[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row246[] = {
+static int parser_action_row252[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row247[] = {
+static int parser_action_row253[] = {
13,
-1, 1, 354,
- 59, 0, 475,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 483,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row248[] = {
+static int parser_action_row254[] = {
1,
- -1, 1, 400
+ -1, 1, 402
};
-static int parser_action_row249[] = {
+static int parser_action_row255[] = {
1,
- -1, 1, 401
+ -1, 1, 403
};
-static int parser_action_row250[] = {
+static int parser_action_row256[] = {
1,
- -1, 1, 1078
+ -1, 1, 1086
};
-static int parser_action_row251[] = {
+static int parser_action_row257[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row252[] = {
+static int parser_action_row258[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row253[] = {
+static int parser_action_row259[] = {
3,
- -1, 3, 252,
- 104, 0, 247,
- 105, 0, 248
+ -1, 3, 258,
+ 106, 0, 253,
+ 107, 0, 254
};
-static int parser_action_row254[] = {
- 26,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row260[] = {
+ 28,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 104, 1, 396,
- 105, 1, 396,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 106, 1, 398,
+ 107, 1, 398,
+ 108, 0, 62
};
-static int parser_action_row255[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row261[] = {
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 349,
73, 1, 349,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row256[] = {
+static int parser_action_row262[] = {
13,
-1, 1, 331,
- 59, 0, 484,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 492,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row257[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row263[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row258[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row264[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 343,
- 59, 0, 488,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 496,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 343,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row259[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row265[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row260[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row266[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 347,
- 58, 0, 215,
- 59, 0, 493,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 501,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 347,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row261[] = {
+static int parser_action_row267[] = {
1,
- -1, 1, 1087
+ -1, 1, 1095
};
-static int parser_action_row262[] = {
+static int parser_action_row268[] = {
3,
- -1, 1, 456,
- 12, 0, 497,
- 97, 0, 498
+ -1, 1, 458,
+ 12, 0, 505,
+ 97, 0, 506
};
-static int parser_action_row263[] = {
+static int parser_action_row269[] = {
2,
- -1, 3, 262,
- 102, 0, 499
+ -1, 3, 268,
+ 104, 0, 507
};
-static int parser_action_row264[] = {
+static int parser_action_row270[] = {
1,
-1, 1, 142
};
-static int parser_action_row265[] = {
+static int parser_action_row271[] = {
1,
-1, 1, 6
};
-static int parser_action_row266[] = {
+static int parser_action_row272[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row267[] = {
+static int parser_action_row273[] = {
1,
-1, 1, 10
};
-static int parser_action_row268[] = {
+static int parser_action_row274[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row269[] = {
+static int parser_action_row275[] = {
1,
-1, 1, 12
};
-static int parser_action_row270[] = {
+static int parser_action_row276[] = {
1,
- -1, 1, 483
+ -1, 1, 485
};
-static int parser_action_row271[] = {
+static int parser_action_row277[] = {
1,
- -1, 1, 482
+ -1, 1, 484
};
-static int parser_action_row272[] = {
+static int parser_action_row278[] = {
4,
- -1, 1, 480,
+ -1, 1, 482,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row273[] = {
+static int parser_action_row279[] = {
8,
- -1, 3, 272,
- 4, 0, 462,
- 5, 0, 463,
- 6, 0, 464,
- 7, 0, 465,
- 8, 0, 466,
- 10, 0, 467,
- 17, 0, 468
+ -1, 3, 278,
+ 4, 0, 470,
+ 5, 0, 471,
+ 6, 0, 472,
+ 7, 0, 473,
+ 8, 0, 474,
+ 10, 0, 475,
+ 17, 0, 476
};
-static int parser_action_row274[] = {
+static int parser_action_row280[] = {
1,
-1, 1, 7
};
-static int parser_action_row275[] = {
+static int parser_action_row281[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3,
- 110, 1, 22
+ 112, 1, 22
};
-static int parser_action_row276[] = {
+static int parser_action_row282[] = {
1,
-1, 1, 11
};
-static int parser_action_row277[] = {
+static int parser_action_row283[] = {
1,
-1, 1, 13
};
-static int parser_action_row278[] = {
+static int parser_action_row284[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row279[] = {
+static int parser_action_row285[] = {
1,
- -1, 1, 767
+ -1, 1, 771
};
-static int parser_action_row280[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row286[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row281[] = {
- 21,
- -1, 1, 458,
- 12, 0, 116,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row287[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 118,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row282[] = {
+static int parser_action_row288[] = {
3,
- -1, 3, 281,
- 47, 0, 387,
- 96, 0, 388
+ -1, 3, 287,
+ 47, 0, 395,
+ 96, 0, 396
};
-static int parser_action_row283[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row289[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row284[] = {
+static int parser_action_row290[] = {
1,
- -1, 1, 784
+ -1, 1, 788
};
-static int parser_action_row285[] = {
+static int parser_action_row291[] = {
1,
- -1, 1, 785
+ -1, 1, 789
};
-static int parser_action_row286[] = {
+static int parser_action_row292[] = {
1,
- -1, 1, 786
+ -1, 1, 790
};
-static int parser_action_row287[] = {
+static int parser_action_row293[] = {
1,
- -1, 1, 787
+ -1, 1, 791
};
-static int parser_action_row288[] = {
+static int parser_action_row294[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row289[] = {
+static int parser_action_row295[] = {
3,
- -1, 3, 288,
- 41, 0, 300,
- 98, 0, 510
+ -1, 3, 294,
+ 41, 0, 308,
+ 98, 0, 518
};
-static int parser_action_row290[] = {
+static int parser_action_row296[] = {
3,
- -1, 3, 289,
- 54, 0, 244,
- 73, 0, 511
+ -1, 3, 295,
+ 54, 0, 250,
+ 73, 0, 519
};
-static int parser_action_row291[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row297[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
- 53, 0, 512,
+ 53, 0, 520,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 513,
+ 97, 0, 521,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row292[] = {
+static int parser_action_row298[] = {
1,
- -1, 1, 736
+ -1, 1, 740
};
-static int parser_action_row293[] = {
+static int parser_action_row299[] = {
1,
- -1, 1, 735
+ -1, 1, 739
};
-static int parser_action_row294[] = {
+static int parser_action_row300[] = {
1,
- -1, 1, 737
+ -1, 1, 741
};
-static int parser_action_row295[] = {
+static int parser_action_row301[] = {
1,
- -1, 1, 755
+ -1, 1, 759
};
-static int parser_action_row296[] = {
+static int parser_action_row302[] = {
1,
- -1, 1, 788
+ -1, 1, 792
};
-static int parser_action_row297[] = {
+static int parser_action_row303[] = {
1,
- -1, 1, 789
+ -1, 1, 793
};
-static int parser_action_row298[] = {
+static int parser_action_row304[] = {
1,
- -1, 1, 790
+ -1, 1, 794
};
-static int parser_action_row299[] = {
+static int parser_action_row305[] = {
1,
- -1, 1, 792
+ -1, 1, 795
};
-static int parser_action_row300[] = {
+static int parser_action_row306[] = {
1,
- -1, 1, 791
+ -1, 1, 796
};
-static int parser_action_row301[] = {
+static int parser_action_row307[] = {
+ 1,
+ -1, 1, 798
+};
+static int parser_action_row308[] = {
+ 1,
+ -1, 1, 797
+};
+static int parser_action_row309[] = {
2,
- -1, 1, 764,
- 52, 0, 277
+ -1, 1, 768,
+ 52, 0, 283
};
-static int parser_action_row302[] = {
+static int parser_action_row310[] = {
1,
- -1, 1, 746
+ -1, 1, 750
};
-static int parser_action_row303[] = {
+static int parser_action_row311[] = {
2,
- -1, 1, 758,
- 52, 0, 277
+ -1, 1, 762,
+ 52, 0, 283
};
-static int parser_action_row304[] = {
+static int parser_action_row312[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row305[] = {
+static int parser_action_row313[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 24, 0, 520
+ 24, 0, 528
};
-static int parser_action_row306[] = {
+static int parser_action_row314[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row307[] = {
+static int parser_action_row315[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row308[] = {
+static int parser_action_row316[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row309[] = {
+static int parser_action_row317[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row310[] = {
+static int parser_action_row318[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row311[] = {
+static int parser_action_row319[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row312[] = {
+static int parser_action_row320[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row313[] = {
+static int parser_action_row321[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row314[] = {
+static int parser_action_row322[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row315[] = {
+static int parser_action_row323[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row316[] = {
+static int parser_action_row324[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row317[] = {
+static int parser_action_row325[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row318[] = {
+static int parser_action_row326[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row319[] = {
+static int parser_action_row327[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row320[] = {
+static int parser_action_row328[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row321[] = {
+static int parser_action_row329[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row322[] = {
+static int parser_action_row330[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row323[] = {
+static int parser_action_row331[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row324[] = {
+static int parser_action_row332[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row325[] = {
+static int parser_action_row333[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row326[] = {
+static int parser_action_row334[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row327[] = {
+static int parser_action_row335[] = {
1,
- -1, 1, 769
+ -1, 1, 773
};
-static int parser_action_row328[] = {
+static int parser_action_row336[] = {
3,
- -1, 1, 762,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 766,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row329[] = {
+static int parser_action_row337[] = {
2,
- -1, 1, 456,
- 97, 0, 544
+ -1, 1, 458,
+ 97, 0, 552
};
-static int parser_action_row330[] = {
+static int parser_action_row338[] = {
2,
-1, 1, 157,
- 49, 1, 980
+ 49, 1, 988
};
-static int parser_action_row331[] = {
+static int parser_action_row339[] = {
2,
-1, 1, 156,
- 49, 1, 979
+ 49, 1, 987
};
-static int parser_action_row332[] = {
+static int parser_action_row340[] = {
4,
- -1, 3, 331,
+ -1, 3, 339,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row333[] = {
+static int parser_action_row341[] = {
1,
-1, 1, 256
};
-static int parser_action_row334[] = {
+static int parser_action_row342[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row335[] = {
+static int parser_action_row343[] = {
2,
-1, 1, 203,
- 59, 0, 548
+ 59, 0, 556
};
-static int parser_action_row336[] = {
+static int parser_action_row344[] = {
2,
-1, 1, 155,
- 57, 0, 333
+ 57, 0, 341
};
-static int parser_action_row337[] = {
+static int parser_action_row345[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row338[] = {
+static int parser_action_row346[] = {
3,
- -1, 1, 1052,
- 0, 0, 102,
- 1, 0, 103
+ -1, 1, 1060,
+ 0, 0, 104,
+ 1, 0, 105
};
-static int parser_action_row339[] = {
+static int parser_action_row347[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row340[] = {
+static int parser_action_row348[] = {
1,
-1, 1, 267
};
-static int parser_action_row341[] = {
+static int parser_action_row349[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row342[] = {
+static int parser_action_row350[] = {
1,
- -1, 1, 449
+ -1, 1, 451
};
-static int parser_action_row343[] = {
+static int parser_action_row351[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row344[] = {
+static int parser_action_row352[] = {
2,
- -1, 1, 448,
- 56, 0, 554
+ -1, 1, 450,
+ 56, 0, 562
};
-static int parser_action_row345[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row353[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row346[] = {
- 23,
- -1, 1, 458,
- 12, 0, 170,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row354[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 174,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row347[] = {
+static int parser_action_row355[] = {
3,
- -1, 3, 346,
- 47, 0, 387,
- 96, 0, 388
+ -1, 3, 354,
+ 47, 0, 395,
+ 96, 0, 396
};
-static int parser_action_row348[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row356[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row349[] = {
+static int parser_action_row357[] = {
3,
- -1, 3, 348,
- 54, 0, 244,
- 73, 0, 559
+ -1, 3, 356,
+ 54, 0, 250,
+ 73, 0, 567
};
-static int parser_action_row350[] = {
+static int parser_action_row358[] = {
3,
- -1, 3, 349,
- 41, 0, 378,
- 98, 0, 560
+ -1, 3, 357,
+ 41, 0, 386,
+ 98, 0, 568
};
-static int parser_action_row351[] = {
+static int parser_action_row359[] = {
1,
-1, 1, 321
};
-static int parser_action_row352[] = {
+static int parser_action_row360[] = {
1,
-1, 1, 320
};
-static int parser_action_row353[] = {
+static int parser_action_row361[] = {
1,
-1, 1, 322
};
-static int parser_action_row354[] = {
+static int parser_action_row362[] = {
1,
-1, 1, 340
};
-static int parser_action_row355[] = {
+static int parser_action_row363[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row356[] = {
+static int parser_action_row364[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 24, 0, 562
+ 24, 0, 570
};
-static int parser_action_row357[] = {
+static int parser_action_row365[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row358[] = {
+static int parser_action_row366[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row359[] = {
+static int parser_action_row367[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row360[] = {
+static int parser_action_row368[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row361[] = {
+static int parser_action_row369[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row362[] = {
+static int parser_action_row370[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row363[] = {
+static int parser_action_row371[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row364[] = {
+static int parser_action_row372[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row365[] = {
+static int parser_action_row373[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row366[] = {
+static int parser_action_row374[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row367[] = {
+static int parser_action_row375[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row368[] = {
+static int parser_action_row376[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row369[] = {
+static int parser_action_row377[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row370[] = {
+static int parser_action_row378[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row371[] = {
+static int parser_action_row379[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row372[] = {
+static int parser_action_row380[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row373[] = {
+static int parser_action_row381[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row374[] = {
+static int parser_action_row382[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row375[] = {
+static int parser_action_row383[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row376[] = {
+static int parser_action_row384[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row377[] = {
+static int parser_action_row385[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row378[] = {
+static int parser_action_row386[] = {
1,
-1, 1, 354
};
-static int parser_action_row379[] = {
+static int parser_action_row387[] = {
2,
-1, 1, 349,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row380[] = {
+static int parser_action_row388[] = {
1,
-1, 1, 331
};
-static int parser_action_row381[] = {
+static int parser_action_row389[] = {
2,
-1, 1, 343,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row382[] = {
+static int parser_action_row390[] = {
3,
-1, 1, 347,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row383[] = {
+static int parser_action_row391[] = {
2,
- -1, 1, 456,
- 97, 0, 587
+ -1, 1, 458,
+ 97, 0, 595
};
-static int parser_action_row384[] = {
+static int parser_action_row392[] = {
1,
-1, 1, 202
};
-static int parser_action_row385[] = {
+static int parser_action_row393[] = {
1,
-1, 1, 282
};
-static int parser_action_row386[] = {
+static int parser_action_row394[] = {
2,
-1, 1, 281,
- 24, 0, 588
+ 24, 0, 596
};
-static int parser_action_row387[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row395[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row388[] = {
+static int parser_action_row396[] = {
2,
- -1, 3, 387,
- 96, 0, 592
+ -1, 3, 395,
+ 96, 0, 600
};
-static int parser_action_row389[] = {
+static int parser_action_row397[] = {
3,
- -1, 1, 797,
- 54, 0, 593,
- 94, 0, 594
+ -1, 1, 803,
+ 54, 0, 601,
+ 94, 0, 602
};
-static int parser_action_row390[] = {
+static int parser_action_row398[] = {
2,
- -1, 3, 389,
- 73, 0, 597
+ -1, 3, 397,
+ 73, 0, 605
};
-static int parser_action_row391[] = {
+static int parser_action_row399[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row392[] = {
+static int parser_action_row400[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row393[] = {
+static int parser_action_row401[] = {
1,
- -1, 1, 402
+ -1, 1, 404
};
-static int parser_action_row394[] = {
+static int parser_action_row402[] = {
6,
-1, 1, 341,
- 52, 0, 277,
- 57, 0, 333,
- 58, 0, 215,
+ 52, 0, 283,
+ 57, 0, 341,
+ 58, 0, 219,
59, 1, 155,
- 94, 0, 204
+ 94, 0, 208
};
-static int parser_action_row395[] = {
+static int parser_action_row403[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row396[] = {
+static int parser_action_row404[] = {
1,
-1, 1, 277
};
-static int parser_action_row397[] = {
+static int parser_action_row405[] = {
2,
- -1, 3, 396,
- 96, 0, 603
+ -1, 3, 404,
+ 96, 0, 611
};
-static int parser_action_row398[] = {
+static int parser_action_row406[] = {
3,
- -1, 1, 405,
- 54, 0, 604,
- 94, 0, 204
+ -1, 1, 407,
+ 54, 0, 612,
+ 94, 0, 208
};
-static int parser_action_row399[] = {
+static int parser_action_row407[] = {
2,
- -1, 3, 398,
- 57, 0, 606
+ -1, 3, 406,
+ 57, 0, 614
};
-static int parser_action_row400[] = {
- 26,
- -1, 1, 987,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row408[] = {
+ 28,
+ -1, 1, 995,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row401[] = {
+static int parser_action_row409[] = {
2,
- -1, 1, 992,
- 49, 0, 197
+ -1, 1, 1000,
+ 49, 0, 201
};
-static int parser_action_row402[] = {
+static int parser_action_row410[] = {
2,
- -1, 1, 989,
- 49, 0, 197
+ -1, 1, 997,
+ 49, 0, 201
};
-static int parser_action_row403[] = {
+static int parser_action_row411[] = {
1,
- -1, 1, 991
+ -1, 1, 999
};
-static int parser_action_row404[] = {
+static int parser_action_row412[] = {
2,
- -1, 3, 403,
- 11, 0, 610
+ -1, 3, 411,
+ 11, 0, 618
};
-static int parser_action_row405[] = {
+static int parser_action_row413[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 55, 0, 611
+ 55, 0, 619
};
-static int parser_action_row406[] = {
- 24,
- -1, 1, 498,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row414[] = {
+ 26,
+ -1, 1, 500,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row407[] = {
- 24,
- -1, 1, 499,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row415[] = {
+ 26,
+ -1, 1, 501,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
-};
-static int parser_action_row408[] = {
- 1,
- -1, 1, 500
-};
-static int parser_action_row409[] = {
- 1,
- -1, 1, 501
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row410[] = {
+static int parser_action_row416[] = {
1,
-1, 1, 502
};
-static int parser_action_row411[] = {
+static int parser_action_row417[] = {
1,
-1, 1, 503
};
-static int parser_action_row412[] = {
+static int parser_action_row418[] = {
1,
-1, 1, 504
};
-static int parser_action_row413[] = {
+static int parser_action_row419[] = {
1,
-1, 1, 505
};
-static int parser_action_row414[] = {
+static int parser_action_row420[] = {
1,
-1, 1, 506
};
-static int parser_action_row415[] = {
- 24,
- -1, 1, 507,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row421[] = {
+ 1,
+ -1, 1, 507
+};
+static int parser_action_row422[] = {
+ 1,
+ -1, 1, 508
+};
+static int parser_action_row423[] = {
+ 26,
+ -1, 1, 509,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
-};
-static int parser_action_row416[] = {
- 1,
- -1, 1, 508
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row417[] = {
- 1,
- -1, 1, 509
-};
-static int parser_action_row418[] = {
- 1,
- -1, 1, 512
-};
-static int parser_action_row419[] = {
+static int parser_action_row424[] = {
1,
-1, 1, 510
};
-static int parser_action_row420[] = {
- 1,
- -1, 1, 514
-};
-static int parser_action_row421[] = {
- 1,
- -1, 1, 513
-};
-static int parser_action_row422[] = {
+static int parser_action_row425[] = {
1,
-1, 1, 511
};
-static int parser_action_row423[] = {
- 1,
- -1, 1, 515
-};
-static int parser_action_row424[] = {
- 1,
- -1, 1, 517
-};
-static int parser_action_row425[] = {
- 4,
- -1, 1, 405,
- 54, 0, 604,
- 58, 0, 214,
- 94, 0, 204
-};
static int parser_action_row426[] = {
- 15,
- -1, 1, 341,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 612,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 1,
+ -1, 1, 514
};
static int parser_action_row427[] = {
1,
- -1, 1, 428
+ -1, 1, 512
};
static int parser_action_row428[] = {
1,
- -1, 1, 985
+ -1, 1, 516
};
static int parser_action_row429[] = {
1,
- -1, 1, 986
+ -1, 1, 515
};
static int parser_action_row430[] = {
1,
- -1, 1, 994
+ -1, 1, 513
};
static int parser_action_row431[] = {
1,
- -1, 1, 996
+ -1, 1, 517
};
static int parser_action_row432[] = {
1,
- -1, 1, 995
+ -1, 1, 519
};
static int parser_action_row433[] = {
- 1,
- -1, 1, 997
+ 4,
+ -1, 1, 407,
+ 54, 0, 612,
+ 58, 0, 218,
+ 94, 0, 208
};
static int parser_action_row434[] = {
- 1,
- -1, 1, 998
+ 15,
+ -1, 1, 341,
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 620,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
static int parser_action_row435[] = {
1,
- -1, 1, 999
+ -1, 1, 430
};
static int parser_action_row436[] = {
1,
- -1, 1, 429
+ -1, 1, 993
};
static int parser_action_row437[] = {
- 3,
- -1, 1, 324,
- 54, 0, 244,
- 73, 0, 613
+ 1,
+ -1, 1, 994
};
static int parser_action_row438[] = {
- 3,
- -1, 1, 487,
- 0, 0, 1,
- 1, 0, 2
+ 1,
+ -1, 1, 1002
};
static int parser_action_row439[] = {
1,
- -1, 1, 433
+ -1, 1, 1004
};
static int parser_action_row440[] = {
- 4,
- -1, 1, 487,
- 0, 0, 1,
- 1, 0, 2,
- 56, 0, 615
+ 1,
+ -1, 1, 1003
};
static int parser_action_row441[] = {
- 3,
- -1, 3, 440,
- 41, 0, 378,
- 98, 0, 255
+ 1,
+ -1, 1, 1005
};
static int parser_action_row442[] = {
- 22,
- -1, 1, 455,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 623
+ 1,
+ -1, 1, 1006
};
static int parser_action_row443[] = {
1,
- -1, 1, 520
+ -1, 1, 1007
};
static int parser_action_row444[] = {
1,
- -1, 1, 432
+ -1, 1, 431
};
static int parser_action_row445[] = {
- 1,
- -1, 1, 430
+ 3,
+ -1, 1, 324,
+ 54, 0, 250,
+ 73, 0, 621
};
static int parser_action_row446[] = {
- 23,
- -1, 1, 457,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 625
-};
-static int parser_action_row447[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
+static int parser_action_row447[] = {
+ 1,
+ -1, 1, 435
+};
static int parser_action_row448[] = {
- 3,
- -1, 1, 487,
+ 4,
+ -1, 1, 489,
0, 0, 1,
- 1, 0, 2
+ 1, 0, 2,
+ 56, 0, 623
};
static int parser_action_row449[] = {
3,
- -1, 1, 487,
- 0, 0, 1,
- 1, 0, 2
+ -1, 3, 448,
+ 41, 0, 386,
+ 98, 0, 261
};
static int parser_action_row450[] = {
- 2,
- -1, 1, 155,
- 57, 0, 333
+ 22,
+ -1, 1, 457,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 631
};
static int parser_action_row451[] = {
- 2,
- -1, 1, 387,
- 56, 0, 632
+ 1,
+ -1, 1, 522
};
static int parser_action_row452[] = {
1,
- -1, 1, 468
+ -1, 1, 434
};
static int parser_action_row453[] = {
1,
- -1, 1, 467
+ -1, 1, 432
};
static int parser_action_row454[] = {
+ 23,
+ -1, 1, 459,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 633
+};
+static int parser_action_row455[] = {
+ 3,
+ -1, 1, 489,
+ 0, 0, 1,
+ 1, 0, 2
+};
+static int parser_action_row456[] = {
+ 3,
+ -1, 1, 489,
+ 0, 0, 1,
+ 1, 0, 2
+};
+static int parser_action_row457[] = {
+ 3,
+ -1, 1, 489,
+ 0, 0, 1,
+ 1, 0, 2
+};
+static int parser_action_row458[] = {
+ 2,
+ -1, 1, 155,
+ 57, 0, 341
+};
+static int parser_action_row459[] = {
+ 2,
+ -1, 1, 389,
+ 56, 0, 640
+};
+static int parser_action_row460[] = {
+ 1,
+ -1, 1, 470
+};
+static int parser_action_row461[] = {
+ 1,
+ -1, 1, 469
+};
+static int parser_action_row462[] = {
1,
-1, 1, 218
};
-static int parser_action_row455[] = {
+static int parser_action_row463[] = {
1,
-1, 1, 237
};
-static int parser_action_row456[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row464[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row457[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row465[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row458[] = {
+static int parser_action_row466[] = {
1,
-1, 1, 82
};
-static int parser_action_row459[] = {
+static int parser_action_row467[] = {
1,
-1, 1, 84
};
-static int parser_action_row460[] = {
+static int parser_action_row468[] = {
1,
-1, 1, 83
};
-static int parser_action_row461[] = {
+static int parser_action_row469[] = {
1,
-1, 1, 85
};
-static int parser_action_row462[] = {
+static int parser_action_row470[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row463[] = {
+static int parser_action_row471[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row464[] = {
+static int parser_action_row472[] = {
1,
-1, 1, 32
};
-static int parser_action_row465[] = {
+static int parser_action_row473[] = {
2,
- -1, 3, 464,
- 5, 0, 639
+ -1, 3, 472,
+ 5, 0, 647
};
-static int parser_action_row466[] = {
+static int parser_action_row474[] = {
1,
-1, 1, 34
};
-static int parser_action_row467[] = {
+static int parser_action_row475[] = {
1,
-1, 1, 35
};
-static int parser_action_row468[] = {
+static int parser_action_row476[] = {
23,
- -1, 3, 467,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ -1, 3, 475,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row469[] = {
+static int parser_action_row477[] = {
2,
- -1, 3, 468,
- 5, 0, 665
+ -1, 3, 476,
+ 5, 0, 673
};
-static int parser_action_row470[] = {
+static int parser_action_row478[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row471[] = {
+static int parser_action_row479[] = {
1,
-1, 1, 166
};
-static int parser_action_row472[] = {
+static int parser_action_row480[] = {
1,
- -1, 1, 1073
+ -1, 1, 1081
};
-static int parser_action_row473[] = {
- 32,
+static int parser_action_row481[] = {
+ 34,
-1, 1, 163,
12, 0, 31,
15, 0, 33,
36, 0, 42,
37, 0, 43,
38, 0, 44,
- 41, 1, 458,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
54, 0, 52,
96, 0, 53,
97, 0, 54,
- 98, 1, 458,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row474[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row482[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 513,
+ 97, 0, 521,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row475[] = {
+static int parser_action_row483[] = {
5,
- -1, 1, 458,
- 12, 0, 668,
- 46, 0, 669,
+ -1, 1, 460,
+ 12, 0, 676,
+ 46, 0, 677,
96, 0, 53,
- 97, 0, 670
+ 97, 0, 678
};
-static int parser_action_row476[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row484[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row477[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row485[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row478[] = {
- 26,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row486[] = {
+ 28,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 104, 1, 399,
- 105, 1, 399,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 106, 1, 401,
+ 107, 1, 401,
+ 108, 0, 62
};
-static int parser_action_row479[] = {
+static int parser_action_row487[] = {
1,
- -1, 1, 393
+ -1, 1, 395
};
-static int parser_action_row480[] = {
+static int parser_action_row488[] = {
1,
- -1, 1, 1079
+ -1, 1, 1087
};
-static int parser_action_row481[] = {
+static int parser_action_row489[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row482[] = {
+static int parser_action_row490[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row483[] = {
+static int parser_action_row491[] = {
1,
-1, 1, 348
};
-static int parser_action_row484[] = {
+static int parser_action_row492[] = {
1,
-1, 1, 191
};
-static int parser_action_row485[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row493[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row486[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row494[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row487[] = {
+static int parser_action_row495[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row488[] = {
+static int parser_action_row496[] = {
1,
-1, 1, 197
};
-static int parser_action_row489[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row497[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row490[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row498[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row491[] = {
+static int parser_action_row499[] = {
13,
-1, 1, 342,
- 59, 0, 684,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 692,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row492[] = {
+static int parser_action_row500[] = {
1,
-1, 1, 188
};
-static int parser_action_row493[] = {
+static int parser_action_row501[] = {
1,
-1, 1, 199
};
-static int parser_action_row494[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row502[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row495[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row503[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row496[] = {
+static int parser_action_row504[] = {
13,
-1, 1, 346,
- 59, 0, 688,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 696,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row497[] = {
+static int parser_action_row505[] = {
1,
-1, 1, 190
};
-static int parser_action_row498[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row506[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row499[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row507[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 345,
- 59, 0, 691,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 699,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 345,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row500[] = {
+static int parser_action_row508[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row501[] = {
+static int parser_action_row509[] = {
1,
-1, 1, 14
};
-static int parser_action_row502[] = {
+static int parser_action_row510[] = {
7,
- -1, 3, 501,
- 5, 0, 463,
- 6, 0, 464,
- 7, 0, 465,
- 8, 0, 466,
- 10, 0, 467,
- 17, 0, 468
+ -1, 3, 509,
+ 5, 0, 471,
+ 6, 0, 472,
+ 7, 0, 473,
+ 8, 0, 474,
+ 10, 0, 475,
+ 17, 0, 476
};
-static int parser_action_row503[] = {
+static int parser_action_row511[] = {
1,
- -1, 1, 484
+ -1, 1, 486
};
-static int parser_action_row504[] = {
+static int parser_action_row512[] = {
1,
-1, 1, 15
};
-static int parser_action_row505[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row513[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
- 53, 0, 696,
+ 53, 0, 704,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 513,
+ 97, 0, 521,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row506[] = {
+static int parser_action_row514[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row507[] = {
+static int parser_action_row515[] = {
1,
- -1, 1, 706
+ -1, 1, 710
};
-static int parser_action_row508[] = {
+static int parser_action_row516[] = {
3,
- -1, 1, 741,
- 52, 0, 277,
- 73, 0, 699
+ -1, 1, 745,
+ 52, 0, 283,
+ 73, 0, 707
};
-static int parser_action_row509[] = {
+static int parser_action_row517[] = {
1,
- -1, 1, 738
+ -1, 1, 742
};
-static int parser_action_row510[] = {
+static int parser_action_row518[] = {
3,
- -1, 3, 509,
- 47, 0, 387,
- 96, 0, 388
+ -1, 3, 517,
+ 47, 0, 395,
+ 96, 0, 396
};
-static int parser_action_row511[] = {
+static int parser_action_row519[] = {
3,
- -1, 1, 743,
- 54, 1, 746,
- 73, 1, 746
+ -1, 1, 747,
+ 54, 1, 750,
+ 73, 1, 750
};
-static int parser_action_row512[] = {
+static int parser_action_row520[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row513[] = {
+static int parser_action_row521[] = {
9,
- -1, 1, 438,
- 0, 1, 441,
- 1, 1, 441,
- 9, 1, 441,
- 24, 1, 441,
- 53, 1, 441,
- 56, 1, 441,
- 95, 1, 441,
- 110, 1, 441
+ -1, 1, 440,
+ 0, 1, 443,
+ 1, 1, 443,
+ 9, 1, 443,
+ 24, 1, 443,
+ 53, 1, 443,
+ 56, 1, 443,
+ 95, 1, 443,
+ 112, 1, 443
};
-static int parser_action_row514[] = {
+static int parser_action_row522[] = {
4,
-1, 1, 341,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 703
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 711
};
-static int parser_action_row515[] = {
+static int parser_action_row523[] = {
2,
-1, 1, 366,
- 71, 0, 704
+ 71, 0, 712
};
-static int parser_action_row516[] = {
+static int parser_action_row524[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row517[] = {
+static int parser_action_row525[] = {
2,
- -1, 3, 516,
- 53, 0, 706
+ -1, 3, 524,
+ 53, 0, 714
};
-static int parser_action_row518[] = {
+static int parser_action_row526[] = {
1,
- -1, 1, 763
+ -1, 1, 767
};
-static int parser_action_row519[] = {
+static int parser_action_row527[] = {
1,
- -1, 1, 757
+ -1, 1, 761
};
-static int parser_action_row520[] = {
- 21,
- -1, 1, 458,
- 12, 0, 116,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row528[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 118,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row521[] = {
+static int parser_action_row529[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row522[] = {
- 21,
- -1, 1, 458,
- 12, 0, 116,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row523[] = {
- 21,
- -1, 1, 458,
- 12, 0, 116,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row524[] = {
- 3,
- -1, 3, 523,
- 47, 0, 396,
- 96, 0, 397
-};
-static int parser_action_row525[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row526[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row527[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row528[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
-static int parser_action_row529[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
-};
static int parser_action_row530[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 23,
+ -1, 1, 460,
+ 12, 0, 118,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row531[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 23,
+ -1, 1, 460,
+ 12, 0, 118,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row532[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 3,
+ -1, 3, 531,
+ 47, 0, 404,
+ 96, 0, 405
};
static int parser_action_row533[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row534[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row535[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row536[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row537[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row538[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row539[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row540[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row541[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row542[] = {
- 20,
- -1, 1, 458,
- 12, 0, 116,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
static int parser_action_row543[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row544[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row545[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row546[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row547[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row548[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row549[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row550[] = {
+ 22,
+ -1, 1, 460,
+ 12, 0, 118,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
+};
+static int parser_action_row551[] = {
5,
- -1, 1, 458,
- 12, 0, 730,
- 46, 0, 731,
+ -1, 1, 460,
+ 12, 0, 738,
+ 46, 0, 739,
96, 0, 53,
- 97, 0, 732
+ 97, 0, 740
};
-static int parser_action_row544[] = {
+static int parser_action_row552[] = {
1,
- -1, 1, 761
+ -1, 1, 765
};
-static int parser_action_row545[] = {
+static int parser_action_row553[] = {
2,
- -1, 1, 760,
- 52, 0, 277
+ -1, 1, 764,
+ 52, 0, 283
};
-static int parser_action_row546[] = {
- 31,
- -1, 1, 458,
- 9, 0, 737,
+static int parser_action_row554[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 745,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row547[] = {
+static int parser_action_row555[] = {
4,
- -1, 3, 546,
+ -1, 3, 554,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row548[] = {
+static int parser_action_row556[] = {
3,
- -1, 3, 547,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 555,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row549[] = {
+static int parser_action_row557[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row550[] = {
+static int parser_action_row558[] = {
2,
-1, 1, 204,
- 59, 0, 741
+ 59, 0, 749
};
-static int parser_action_row551[] = {
+static int parser_action_row559[] = {
2,
- -1, 3, 550,
- 23, 0, 742
+ -1, 3, 558,
+ 23, 0, 750
};
-static int parser_action_row552[] = {
+static int parser_action_row560[] = {
2,
- -1, 3, 551,
- 15, 0, 743
+ -1, 3, 559,
+ 15, 0, 751
};
-static int parser_action_row553[] = {
+static int parser_action_row561[] = {
2,
- -1, 3, 552,
- 97, 0, 341
+ -1, 3, 560,
+ 97, 0, 349
};
-static int parser_action_row554[] = {
+static int parser_action_row562[] = {
2,
- -1, 3, 553,
- 28, 0, 745
+ -1, 3, 561,
+ 28, 0, 753
};
-static int parser_action_row555[] = {
+static int parser_action_row563[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row556[] = {
+static int parser_action_row564[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row557[] = {
+static int parser_action_row565[] = {
1,
-1, 1, 291
};
-static int parser_action_row558[] = {
+static int parser_action_row566[] = {
3,
-1, 1, 326,
- 52, 0, 277,
- 73, 0, 597
+ 52, 0, 283,
+ 73, 0, 605
};
-static int parser_action_row559[] = {
+static int parser_action_row567[] = {
1,
-1, 1, 323
};
-static int parser_action_row560[] = {
+static int parser_action_row568[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row561[] = {
+static int parser_action_row569[] = {
3,
-1, 1, 328,
54, 1, 331,
73, 1, 331
};
-static int parser_action_row562[] = {
- 23,
- -1, 1, 458,
- 12, 0, 170,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row570[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 174,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row563[] = {
+static int parser_action_row571[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row564[] = {
- 23,
- -1, 1, 458,
- 12, 0, 170,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row572[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 174,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row565[] = {
- 23,
- -1, 1, 458,
- 12, 0, 170,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row573[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 174,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row566[] = {
+static int parser_action_row574[] = {
3,
- -1, 3, 565,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 573,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row567[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row575[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row568[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row576[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row569[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row577[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row570[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row578[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row571[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row579[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row572[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row580[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row573[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row581[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row574[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row582[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row575[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row583[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row576[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row584[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row577[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row585[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row578[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row586[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row579[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 42, 0, 45,
+static int parser_action_row587[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row580[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row588[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row581[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row589[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row582[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row590[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row583[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row591[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row584[] = {
- 22,
- -1, 1, 458,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row592[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row585[] = {
+static int parser_action_row593[] = {
5,
- -1, 1, 458,
- 12, 0, 773,
- 46, 0, 669,
+ -1, 1, 460,
+ 12, 0, 781,
+ 46, 0, 677,
96, 0, 53,
- 97, 0, 774
+ 97, 0, 782
};
-static int parser_action_row586[] = {
+static int parser_action_row594[] = {
1,
-1, 1, 342
};
-static int parser_action_row587[] = {
+static int parser_action_row595[] = {
1,
-1, 1, 346
};
-static int parser_action_row588[] = {
+static int parser_action_row596[] = {
2,
-1, 1, 345,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row589[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row597[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row590[] = {
+static int parser_action_row598[] = {
1,
-1, 1, 158
};
-static int parser_action_row591[] = {
+static int parser_action_row599[] = {
1,
-1, 1, 278
};
-static int parser_action_row592[] = {
- 31,
- -1, 1, 458,
- 9, 0, 780,
+static int parser_action_row600[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 788,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row593[] = {
+static int parser_action_row601[] = {
3,
- -1, 1, 797,
- 54, 0, 782,
- 94, 0, 594
+ -1, 1, 803,
+ 54, 0, 790,
+ 94, 0, 602
};
-static int parser_action_row594[] = {
+static int parser_action_row602[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row595[] = {
+static int parser_action_row603[] = {
3,
-1, 1, 30,
13, 0, 32,
- 52, 0, 785
+ 52, 0, 793
};
-static int parser_action_row596[] = {
+static int parser_action_row604[] = {
1,
- -1, 1, 796
+ -1, 1, 802
};
-static int parser_action_row597[] = {
+static int parser_action_row605[] = {
1,
- -1, 1, 622
+ -1, 1, 626
};
-static int parser_action_row598[] = {
+static int parser_action_row606[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row599[] = {
+static int parser_action_row607[] = {
2,
-1, 1, 30,
13, 0, 32
};
-static int parser_action_row600[] = {
+static int parser_action_row608[] = {
4,
- -1, 3, 599,
- 6, 0, 792,
- 17, 0, 793,
- 97, 0, 794
+ -1, 3, 607,
+ 6, 0, 800,
+ 17, 0, 801,
+ 97, 0, 802
};
-static int parser_action_row601[] = {
+static int parser_action_row609[] = {
2,
- -1, 3, 600,
- 59, 0, 796
+ -1, 3, 608,
+ 59, 0, 804
};
-static int parser_action_row602[] = {
+static int parser_action_row610[] = {
2,
-1, 1, 155,
- 57, 0, 333
+ 57, 0, 341
};
-static int parser_action_row603[] = {
+static int parser_action_row611[] = {
2,
- -1, 3, 602,
- 15, 0, 798
+ -1, 3, 610,
+ 15, 0, 806
};
-static int parser_action_row604[] = {
+static int parser_action_row612[] = {
3,
- -1, 1, 405,
- 54, 0, 799,
- 94, 0, 204
+ -1, 1, 407,
+ 54, 0, 807,
+ 94, 0, 208
};
-static int parser_action_row605[] = {
+static int parser_action_row613[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row606[] = {
+static int parser_action_row614[] = {
1,
-1, 1, 146
};
-static int parser_action_row607[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row615[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row608[] = {
+static int parser_action_row616[] = {
1,
- -1, 1, 988
+ -1, 1, 996
};
-static int parser_action_row609[] = {
+static int parser_action_row617[] = {
1,
- -1, 1, 993
+ -1, 1, 1001
};
-static int parser_action_row610[] = {
+static int parser_action_row618[] = {
1,
- -1, 1, 990
+ -1, 1, 998
};
-static int parser_action_row611[] = {
+static int parser_action_row619[] = {
3,
- -1, 3, 610,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 618,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row612[] = {
+static int parser_action_row620[] = {
2,
- -1, 1, 516,
- 59, 0, 804
-};
-static int parser_action_row613[] = {
- 26,
-1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+ 59, 0, 812
+};
+static int parser_action_row621[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row614[] = {
+static int parser_action_row622[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row615[] = {
+static int parser_action_row623[] = {
2,
- -1, 3, 614,
- 53, 0, 806
+ -1, 3, 622,
+ 53, 0, 814
};
-static int parser_action_row616[] = {
+static int parser_action_row624[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row617[] = {
+static int parser_action_row625[] = {
1,
- -1, 1, 1074
+ -1, 1, 1082
};
-static int parser_action_row618[] = {
+static int parser_action_row626[] = {
2,
- -1, 3, 617,
- 53, 0, 808
+ -1, 3, 625,
+ 53, 0, 816
};
-static int parser_action_row619[] = {
+static int parser_action_row627[] = {
2,
- -1, 1, 385,
- 56, 0, 615
+ -1, 1, 387,
+ 56, 0, 623
};
-static int parser_action_row620[] = {
+static int parser_action_row628[] = {
2,
- -1, 3, 619,
- 55, 0, 611
+ -1, 3, 627,
+ 55, 0, 619
};
-static int parser_action_row621[] = {
+static int parser_action_row629[] = {
1,
- -1, 1, 498
+ -1, 1, 500
};
-static int parser_action_row622[] = {
+static int parser_action_row630[] = {
1,
- -1, 1, 499
+ -1, 1, 501
};
-static int parser_action_row623[] = {
+static int parser_action_row631[] = {
1,
- -1, 1, 507
+ -1, 1, 509
};
-static int parser_action_row624[] = {
+static int parser_action_row632[] = {
14,
-1, 1, 343,
- 52, 0, 277,
- 59, 0, 810,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 59, 0, 818,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row625[] = {
+static int parser_action_row633[] = {
1,
- -1, 1, 521
+ -1, 1, 523
};
-static int parser_action_row626[] = {
+static int parser_action_row634[] = {
15,
-1, 1, 347,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 811,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 819,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row627[] = {
+static int parser_action_row635[] = {
22,
- -1, 1, 456,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 812
+ -1, 1, 458,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 820
};
-static int parser_action_row628[] = {
+static int parser_action_row636[] = {
1,
- -1, 1, 523
+ -1, 1, 525
};
-static int parser_action_row629[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row637[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row630[] = {
+static int parser_action_row638[] = {
3,
- -1, 3, 629,
- 52, 0, 340,
- 97, 0, 341
+ -1, 3, 637,
+ 52, 0, 348,
+ 97, 0, 349
};
-static int parser_action_row631[] = {
+static int parser_action_row639[] = {
2,
- -1, 1, 390,
- 72, 0, 816
+ -1, 1, 392,
+ 72, 0, 824
};
-static int parser_action_row632[] = {
+static int parser_action_row640[] = {
2,
- -1, 3, 631,
- 55, 0, 817
+ -1, 3, 639,
+ 55, 0, 825
};
-static int parser_action_row633[] = {
+static int parser_action_row641[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row634[] = {
+static int parser_action_row642[] = {
1,
- -1, 1, 1076
+ -1, 1, 1084
};
-static int parser_action_row635[] = {
+static int parser_action_row643[] = {
2,
- -1, 1, 388,
- 56, 0, 632
+ -1, 1, 390,
+ 56, 0, 640
};
-static int parser_action_row636[] = {
+static int parser_action_row644[] = {
1,
-1, 1, 217
};
-static int parser_action_row637[] = {
+static int parser_action_row645[] = {
1,
-1, 1, 236
};
-static int parser_action_row638[] = {
+static int parser_action_row646[] = {
3,
- -1, 3, 637,
- 58, 0, 820,
- 97, 0, 821
+ -1, 3, 645,
+ 58, 0, 828,
+ 97, 0, 829
};
-static int parser_action_row639[] = {
+static int parser_action_row647[] = {
4,
- -1, 3, 638,
- 9, 0, 824,
- 58, 0, 820,
- 97, 0, 821
+ -1, 3, 646,
+ 9, 0, 832,
+ 58, 0, 828,
+ 97, 0, 829
};
-static int parser_action_row640[] = {
+static int parser_action_row648[] = {
1,
-1, 1, 33
};
-static int parser_action_row641[] = {
+static int parser_action_row649[] = {
2,
- -1, 3, 640,
- 55, 0, 826
+ -1, 3, 648,
+ 55, 0, 834
};
-static int parser_action_row642[] = {
+static int parser_action_row650[] = {
1,
-1, 1, 86
};
-static int parser_action_row643[] = {
+static int parser_action_row651[] = {
1,
-1, 1, 87
};
-static int parser_action_row644[] = {
+static int parser_action_row652[] = {
1,
-1, 1, 88
};
-static int parser_action_row645[] = {
+static int parser_action_row653[] = {
1,
-1, 1, 89
};
-static int parser_action_row646[] = {
+static int parser_action_row654[] = {
1,
-1, 1, 90
};
-static int parser_action_row647[] = {
+static int parser_action_row655[] = {
1,
-1, 1, 91
};
-static int parser_action_row648[] = {
+static int parser_action_row656[] = {
1,
-1, 1, 92
};
-static int parser_action_row649[] = {
+static int parser_action_row657[] = {
1,
-1, 1, 93
};
-static int parser_action_row650[] = {
+static int parser_action_row658[] = {
1,
-1, 1, 94
};
-static int parser_action_row651[] = {
+static int parser_action_row659[] = {
1,
-1, 1, 95
};
-static int parser_action_row652[] = {
+static int parser_action_row660[] = {
1,
-1, 1, 96
};
-static int parser_action_row653[] = {
+static int parser_action_row661[] = {
1,
-1, 1, 97
};
-static int parser_action_row654[] = {
+static int parser_action_row662[] = {
1,
-1, 1, 100
};
-static int parser_action_row655[] = {
+static int parser_action_row663[] = {
1,
-1, 1, 98
};
-static int parser_action_row656[] = {
+static int parser_action_row664[] = {
1,
-1, 1, 102
};
-static int parser_action_row657[] = {
+static int parser_action_row665[] = {
1,
-1, 1, 101
};
-static int parser_action_row658[] = {
+static int parser_action_row666[] = {
1,
-1, 1, 99
};
-static int parser_action_row659[] = {
+static int parser_action_row667[] = {
1,
-1, 1, 103
};
-static int parser_action_row660[] = {
+static int parser_action_row668[] = {
1,
-1, 1, 105
};
-static int parser_action_row661[] = {
+static int parser_action_row669[] = {
3,
-1, 1, 108,
- 58, 0, 215,
- 59, 0, 827
+ 58, 0, 219,
+ 59, 0, 835
};
-static int parser_action_row662[] = {
+static int parser_action_row670[] = {
1,
- -1, 1, 463
+ -1, 1, 465
};
-static int parser_action_row663[] = {
+static int parser_action_row671[] = {
5,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 57, 0, 829
+ 52, 0, 836,
+ 57, 0, 837
};
-static int parser_action_row664[] = {
+static int parser_action_row672[] = {
22,
- -1, 3, 663,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 97, 0, 833
+ -1, 3, 671,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 97, 0, 841
};
-static int parser_action_row665[] = {
+static int parser_action_row673[] = {
23,
- -1, 3, 664,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ -1, 3, 672,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row666[] = {
+static int parser_action_row674[] = {
1,
-1, 1, 36
};
-static int parser_action_row667[] = {
+static int parser_action_row675[] = {
3,
- -1, 3, 666,
- 96, 0, 837,
- 97, 0, 838
+ -1, 3, 674,
+ 96, 0, 845,
+ 97, 0, 846
};
-static int parser_action_row668[] = {
+static int parser_action_row676[] = {
2,
- -1, 3, 667,
- 55, 0, 842
+ -1, 3, 675,
+ 55, 0, 850
};
-static int parser_action_row669[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row677[] = {
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 351,
73, 1, 351,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row670[] = {
+static int parser_action_row678[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row671[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row679[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 333,
- 58, 0, 215,
- 59, 0, 846,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 854,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 333,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row672[] = {
+static int parser_action_row680[] = {
2,
- -1, 3, 671,
- 98, 0, 850
+ -1, 3, 679,
+ 98, 0, 858
};
-static int parser_action_row673[] = {
+static int parser_action_row681[] = {
3,
- -1, 1, 455,
- 12, 0, 851,
- 97, 0, 852
+ -1, 1, 457,
+ 12, 0, 859,
+ 97, 0, 860
};
-static int parser_action_row674[] = {
+static int parser_action_row682[] = {
4,
- -1, 1, 457,
- 12, 0, 853,
+ -1, 1, 459,
+ 12, 0, 861,
96, 0, 53,
- 97, 0, 854
+ 97, 0, 862
};
-static int parser_action_row675[] = {
+static int parser_action_row683[] = {
1,
-1, 1, 225
};
-static int parser_action_row676[] = {
+static int parser_action_row684[] = {
1,
-1, 1, 244
};
-static int parser_action_row677[] = {
+static int parser_action_row685[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row678[] = {
+static int parser_action_row686[] = {
1,
- -1, 1, 394
+ -1, 1, 396
};
-static int parser_action_row679[] = {
+static int parser_action_row687[] = {
1,
- -1, 1, 395
+ -1, 1, 397
};
-static int parser_action_row680[] = {
+static int parser_action_row688[] = {
1,
-1, 1, 208
};
-static int parser_action_row681[] = {
+static int parser_action_row689[] = {
1,
-1, 1, 227
};
-static int parser_action_row682[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row690[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
- 53, 0, 857,
+ 53, 0, 865,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 513,
+ 97, 0, 521,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row683[] = {
+static int parser_action_row691[] = {
1,
-1, 1, 220
};
-static int parser_action_row684[] = {
+static int parser_action_row692[] = {
1,
-1, 1, 239
};
-static int parser_action_row685[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row693[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row686[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row694[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row687[] = {
+static int parser_action_row695[] = {
1,
-1, 1, 224
};
-static int parser_action_row688[] = {
+static int parser_action_row696[] = {
1,
-1, 1, 243
};
-static int parser_action_row689[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row697[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row690[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row698[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row691[] = {
+static int parser_action_row699[] = {
1,
-1, 1, 198
};
-static int parser_action_row692[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row700[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row693[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row701[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row694[] = {
+static int parser_action_row702[] = {
13,
-1, 1, 344,
- 59, 0, 865,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 873,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row695[] = {
+static int parser_action_row703[] = {
1,
-1, 1, 189
};
-static int parser_action_row696[] = {
+static int parser_action_row704[] = {
1,
-1, 1, 140
};
-static int parser_action_row697[] = {
+static int parser_action_row705[] = {
1,
- -1, 1, 438
+ -1, 1, 440
};
-static int parser_action_row698[] = {
+static int parser_action_row706[] = {
2,
- -1, 3, 697,
- 53, 0, 867
+ -1, 3, 705,
+ 53, 0, 875
};
-static int parser_action_row699[] = {
+static int parser_action_row707[] = {
2,
- -1, 3, 698,
- 23, 0, 868
+ -1, 3, 706,
+ 23, 0, 876
};
-static int parser_action_row700[] = {
+static int parser_action_row708[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row701[] = {
+static int parser_action_row709[] = {
1,
- -1, 1, 740
+ -1, 1, 744
};
-static int parser_action_row702[] = {
+static int parser_action_row710[] = {
2,
- -1, 3, 701,
- 73, 0, 699
+ -1, 3, 709,
+ 73, 0, 707
};
-static int parser_action_row703[] = {
+static int parser_action_row711[] = {
5,
- -1, 1, 458,
- 12, 0, 730,
- 46, 0, 731,
+ -1, 1, 460,
+ 12, 0, 738,
+ 46, 0, 739,
96, 0, 53,
- 97, 0, 732
+ 97, 0, 740
};
-static int parser_action_row704[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row712[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row705[] = {
+static int parser_action_row713[] = {
1,
-1, 1, 367
};
-static int parser_action_row706[] = {
+static int parser_action_row714[] = {
2,
- -1, 1, 444,
- 56, 0, 872
+ -1, 1, 446,
+ 56, 0, 880
};
-static int parser_action_row707[] = {
+static int parser_action_row715[] = {
9,
- -1, 1, 437,
- 0, 1, 439,
- 1, 1, 439,
- 9, 1, 439,
- 24, 1, 439,
- 53, 1, 439,
- 56, 1, 439,
- 95, 1, 439,
- 110, 1, 439
+ -1, 1, 439,
+ 0, 1, 441,
+ 1, 1, 441,
+ 9, 1, 441,
+ 24, 1, 441,
+ 53, 1, 441,
+ 56, 1, 441,
+ 95, 1, 441,
+ 112, 1, 441
};
-static int parser_action_row708[] = {
+static int parser_action_row716[] = {
1,
- -1, 1, 702
+ -1, 1, 706
};
-static int parser_action_row709[] = {
- 21,
- -1, 1, 458,
- 12, 0, 116,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row717[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 118,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row710[] = {
+static int parser_action_row718[] = {
1,
- -1, 1, 701
+ -1, 1, 705
};
-static int parser_action_row711[] = {
+static int parser_action_row719[] = {
1,
- -1, 1, 704
+ -1, 1, 708
};
-static int parser_action_row712[] = {
+static int parser_action_row720[] = {
1,
- -1, 1, 715
+ -1, 1, 719
};
-static int parser_action_row713[] = {
+static int parser_action_row721[] = {
2,
- -1, 1, 717,
- 81, 0, 315
+ -1, 1, 721,
+ 81, 0, 323
};
-static int parser_action_row714[] = {
+static int parser_action_row722[] = {
2,
- -1, 1, 708,
- 80, 0, 307
+ -1, 1, 712,
+ 80, 0, 315
};
-static int parser_action_row715[] = {
+static int parser_action_row723[] = {
2,
- -1, 1, 709,
- 80, 0, 307
+ -1, 1, 713,
+ 80, 0, 315
};
-static int parser_action_row716[] = {
+static int parser_action_row724[] = {
2,
- -1, 1, 710,
- 80, 0, 307
+ -1, 1, 714,
+ 80, 0, 315
};
-static int parser_action_row717[] = {
+static int parser_action_row725[] = {
2,
- -1, 1, 711,
- 80, 0, 307
+ -1, 1, 715,
+ 80, 0, 315
};
-static int parser_action_row718[] = {
+static int parser_action_row726[] = {
2,
- -1, 1, 712,
- 80, 0, 307
+ -1, 1, 716,
+ 80, 0, 315
};
-static int parser_action_row719[] = {
+static int parser_action_row727[] = {
2,
- -1, 1, 713,
- 80, 0, 307
+ -1, 1, 717,
+ 80, 0, 315
};
-static int parser_action_row720[] = {
+static int parser_action_row728[] = {
2,
- -1, 1, 714,
- 80, 0, 307
+ -1, 1, 718,
+ 80, 0, 315
};
-static int parser_action_row721[] = {
+static int parser_action_row729[] = {
2,
- -1, 1, 719,
- 82, 0, 316
+ -1, 1, 723,
+ 82, 0, 324
};
-static int parser_action_row722[] = {
+static int parser_action_row730[] = {
3,
- -1, 1, 721,
- 88, 0, 317,
- 91, 0, 318
+ -1, 1, 725,
+ 88, 0, 325,
+ 91, 0, 326
};
-static int parser_action_row723[] = {
+static int parser_action_row731[] = {
3,
- -1, 1, 723,
- 74, 0, 319,
- 75, 0, 320
+ -1, 1, 727,
+ 74, 0, 327,
+ 75, 0, 328
};
-static int parser_action_row724[] = {
+static int parser_action_row732[] = {
3,
- -1, 1, 724,
- 74, 0, 319,
- 75, 0, 320
+ -1, 1, 728,
+ 74, 0, 327,
+ 75, 0, 328
};
-static int parser_action_row725[] = {
+static int parser_action_row733[] = {
4,
- -1, 1, 726,
- 76, 0, 321,
- 78, 0, 322,
- 79, 0, 323
+ -1, 1, 730,
+ 76, 0, 329,
+ 78, 0, 330,
+ 79, 0, 331
};
-static int parser_action_row726[] = {
+static int parser_action_row734[] = {
4,
- -1, 1, 727,
- 76, 0, 321,
- 78, 0, 322,
- 79, 0, 323
+ -1, 1, 731,
+ 76, 0, 329,
+ 78, 0, 330,
+ 79, 0, 331
};
-static int parser_action_row727[] = {
+static int parser_action_row735[] = {
1,
- -1, 1, 729
+ -1, 1, 733
};
-static int parser_action_row728[] = {
+static int parser_action_row736[] = {
1,
- -1, 1, 730
+ -1, 1, 734
};
-static int parser_action_row729[] = {
+static int parser_action_row737[] = {
1,
- -1, 1, 731
+ -1, 1, 735
};
-static int parser_action_row730[] = {
+static int parser_action_row738[] = {
1,
- -1, 1, 733
+ -1, 1, 737
};
-static int parser_action_row731[] = {
+static int parser_action_row739[] = {
2,
- -1, 1, 766,
- 52, 0, 277
+ -1, 1, 770,
+ 52, 0, 283
};
-static int parser_action_row732[] = {
+static int parser_action_row740[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row733[] = {
+static int parser_action_row741[] = {
3,
- -1, 1, 748,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 752,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row734[] = {
+static int parser_action_row742[] = {
2,
- -1, 3, 733,
- 98, 0, 879
+ -1, 3, 741,
+ 98, 0, 887
};
-static int parser_action_row735[] = {
+static int parser_action_row743[] = {
2,
- -1, 1, 455,
- 97, 0, 880
+ -1, 1, 457,
+ 97, 0, 888
};
-static int parser_action_row736[] = {
+static int parser_action_row744[] = {
3,
- -1, 1, 457,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 881
+ 97, 0, 889
};
-static int parser_action_row737[] = {
+static int parser_action_row745[] = {
1,
- -1, 1, 759
+ -1, 1, 763
};
-static int parser_action_row738[] = {
+static int parser_action_row746[] = {
1,
-1, 1, 164
};
-static int parser_action_row739[] = {
- 31,
- -1, 1, 458,
- 9, 0, 883,
+static int parser_action_row747[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 891,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row740[] = {
+static int parser_action_row748[] = {
1,
-1, 1, 154
};
-static int parser_action_row741[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row749[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row742[] = {
+static int parser_action_row750[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row743[] = {
- 35,
- -1, 1, 458,
+static int parser_action_row751[] = {
+ 37,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 886,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 894,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 24, 0, 890,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 24, 0, 898,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row744[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row752[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 157,
+ 9, 0, 161,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row745[] = {
+static int parser_action_row753[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 56, 0, 554
+ 56, 0, 562
};
-static int parser_action_row746[] = {
+static int parser_action_row754[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row747[] = {
+static int parser_action_row755[] = {
2,
- -1, 3, 746,
- 97, 0, 923
+ -1, 3, 754,
+ 97, 0, 931
};
-static int parser_action_row748[] = {
+static int parser_action_row756[] = {
2,
- -1, 3, 747,
- 23, 0, 924
+ -1, 3, 755,
+ 23, 0, 932
};
-static int parser_action_row749[] = {
+static int parser_action_row757[] = {
1,
-1, 1, 325
};
-static int parser_action_row750[] = {
+static int parser_action_row758[] = {
5,
- -1, 1, 458,
- 12, 0, 773,
- 46, 0, 669,
+ -1, 1, 460,
+ 12, 0, 781,
+ 46, 0, 677,
96, 0, 53,
- 97, 0, 774
+ 97, 0, 782
};
-static int parser_action_row751[] = {
+static int parser_action_row759[] = {
1,
-1, 1, 287
};
-static int parser_action_row752[] = {
- 23,
- -1, 1, 458,
- 12, 0, 170,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row760[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 174,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row753[] = {
+static int parser_action_row761[] = {
1,
-1, 1, 286
};
-static int parser_action_row754[] = {
+static int parser_action_row762[] = {
1,
-1, 1, 289
};
-static int parser_action_row755[] = {
+static int parser_action_row763[] = {
1,
-1, 1, 300
};
-static int parser_action_row756[] = {
+static int parser_action_row764[] = {
2,
-1, 1, 302,
- 81, 0, 366
+ 81, 0, 374
};
-static int parser_action_row757[] = {
+static int parser_action_row765[] = {
2,
-1, 1, 293,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row758[] = {
+static int parser_action_row766[] = {
2,
-1, 1, 294,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row759[] = {
+static int parser_action_row767[] = {
2,
-1, 1, 295,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row760[] = {
+static int parser_action_row768[] = {
2,
-1, 1, 296,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row761[] = {
+static int parser_action_row769[] = {
2,
-1, 1, 297,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row762[] = {
+static int parser_action_row770[] = {
2,
-1, 1, 298,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row763[] = {
+static int parser_action_row771[] = {
2,
-1, 1, 299,
- 80, 0, 358
+ 80, 0, 366
};
-static int parser_action_row764[] = {
+static int parser_action_row772[] = {
2,
-1, 1, 304,
- 82, 0, 367
+ 82, 0, 375
};
-static int parser_action_row765[] = {
+static int parser_action_row773[] = {
3,
-1, 1, 306,
- 88, 0, 368,
- 91, 0, 369
+ 88, 0, 376,
+ 91, 0, 377
};
-static int parser_action_row766[] = {
+static int parser_action_row774[] = {
3,
-1, 1, 308,
- 74, 0, 370,
- 75, 0, 371
+ 74, 0, 378,
+ 75, 0, 379
};
-static int parser_action_row767[] = {
+static int parser_action_row775[] = {
3,
-1, 1, 309,
- 74, 0, 370,
- 75, 0, 371
+ 74, 0, 378,
+ 75, 0, 379
};
-static int parser_action_row768[] = {
+static int parser_action_row776[] = {
4,
-1, 1, 311,
- 76, 0, 372,
- 78, 0, 373,
- 79, 0, 374
+ 76, 0, 380,
+ 78, 0, 381,
+ 79, 0, 382
};
-static int parser_action_row769[] = {
+static int parser_action_row777[] = {
4,
-1, 1, 312,
- 76, 0, 372,
- 78, 0, 373,
- 79, 0, 374
+ 76, 0, 380,
+ 78, 0, 381,
+ 79, 0, 382
};
-static int parser_action_row770[] = {
+static int parser_action_row778[] = {
1,
-1, 1, 314
};
-static int parser_action_row771[] = {
+static int parser_action_row779[] = {
1,
-1, 1, 315
};
-static int parser_action_row772[] = {
+static int parser_action_row780[] = {
1,
-1, 1, 316
};
-static int parser_action_row773[] = {
+static int parser_action_row781[] = {
1,
-1, 1, 318
};
-static int parser_action_row774[] = {
+static int parser_action_row782[] = {
2,
-1, 1, 351,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row775[] = {
+static int parser_action_row783[] = {
3,
-1, 1, 333,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row776[] = {
+static int parser_action_row784[] = {
2,
- -1, 3, 775,
- 98, 0, 928
+ -1, 3, 783,
+ 98, 0, 936
};
-static int parser_action_row777[] = {
+static int parser_action_row785[] = {
2,
- -1, 1, 455,
- 97, 0, 929
+ -1, 1, 457,
+ 97, 0, 937
};
-static int parser_action_row778[] = {
+static int parser_action_row786[] = {
3,
- -1, 1, 457,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 930
+ 97, 0, 938
};
-static int parser_action_row779[] = {
+static int parser_action_row787[] = {
1,
-1, 1, 344
};
-static int parser_action_row780[] = {
+static int parser_action_row788[] = {
1,
-1, 1, 279
};
-static int parser_action_row781[] = {
+static int parser_action_row789[] = {
1,
-1, 1, 157
};
-static int parser_action_row782[] = {
+static int parser_action_row790[] = {
1,
-1, 1, 156
};
-static int parser_action_row783[] = {
+static int parser_action_row791[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row784[] = {
+static int parser_action_row792[] = {
1,
- -1, 1, 623
+ -1, 1, 627
};
-static int parser_action_row785[] = {
+static int parser_action_row793[] = {
3,
- -1, 3, 784,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 792,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row786[] = {
+static int parser_action_row794[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row787[] = {
+static int parser_action_row795[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row788[] = {
+static int parser_action_row796[] = {
1,
- -1, 1, 794
+ -1, 1, 800
};
-static int parser_action_row789[] = {
+static int parser_action_row797[] = {
3,
- -1, 3, 788,
+ -1, 3, 796,
96, 0, 53,
- 97, 0, 937
+ 97, 0, 945
};
-static int parser_action_row790[] = {
+static int parser_action_row798[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row791[] = {
+static int parser_action_row799[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row792[] = {
+static int parser_action_row800[] = {
2,
- -1, 1, 408,
- 56, 0, 942
+ -1, 1, 410,
+ 56, 0, 950
};
-static int parser_action_row793[] = {
+static int parser_action_row801[] = {
1,
- -1, 1, 436
+ -1, 1, 438
};
-static int parser_action_row794[] = {
+static int parser_action_row802[] = {
1,
- -1, 1, 435
+ -1, 1, 437
};
-static int parser_action_row795[] = {
+static int parser_action_row803[] = {
1,
- -1, 1, 434
+ -1, 1, 436
};
-static int parser_action_row796[] = {
+static int parser_action_row804[] = {
3,
- -1, 1, 405,
- 52, 0, 945,
- 94, 0, 204
+ -1, 1, 407,
+ 52, 0, 953,
+ 94, 0, 208
};
-static int parser_action_row797[] = {
+static int parser_action_row805[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row798[] = {
+static int parser_action_row806[] = {
2,
- -1, 3, 797,
- 59, 0, 948
+ -1, 3, 805,
+ 59, 0, 956
};
-static int parser_action_row799[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row807[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 157,
+ 9, 0, 161,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row800[] = {
+static int parser_action_row808[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row801[] = {
+static int parser_action_row809[] = {
1,
-1, 1, 147
};
-static int parser_action_row802[] = {
+static int parser_action_row810[] = {
3,
- -1, 3, 801,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 809,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row803[] = {
+static int parser_action_row811[] = {
1,
-1, 1, 200
};
-static int parser_action_row804[] = {
+static int parser_action_row812[] = {
2,
- -1, 3, 803,
- 57, 0, 953
+ -1, 3, 811,
+ 57, 0, 961
};
-static int parser_action_row805[] = {
+static int parser_action_row813[] = {
1,
- -1, 1, 519
+ -1, 1, 521
};
-static int parser_action_row806[] = {
+static int parser_action_row814[] = {
25,
- -1, 1, 458,
- 12, 0, 773,
- 46, 0, 669,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 954
+ -1, 1, 460,
+ 12, 0, 781,
+ 46, 0, 677,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 962
};
-static int parser_action_row807[] = {
+static int parser_action_row815[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row808[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row816[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row809[] = {
+static int parser_action_row817[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row810[] = {
+static int parser_action_row818[] = {
1,
- -1, 1, 1075
+ -1, 1, 1083
};
-static int parser_action_row811[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row819[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row812[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row820[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row813[] = {
+static int parser_action_row821[] = {
14,
-1, 1, 345,
- 52, 0, 277,
- 59, 0, 961,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 59, 0, 969,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row814[] = {
+static int parser_action_row822[] = {
1,
- -1, 1, 522
+ -1, 1, 524
};
-static int parser_action_row815[] = {
+static int parser_action_row823[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row816[] = {
+static int parser_action_row824[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row817[] = {
+static int parser_action_row825[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row818[] = {
+static int parser_action_row826[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row819[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 446,
- 27, 0, 447,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row827[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 454,
+ 27, 0, 455,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row820[] = {
+static int parser_action_row828[] = {
1,
- -1, 1, 1077
+ -1, 1, 1085
};
-static int parser_action_row821[] = {
+static int parser_action_row829[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row822[] = {
+static int parser_action_row830[] = {
2,
- -1, 1, 451,
- 58, 0, 215
+ -1, 1, 453,
+ 58, 0, 219
};
-static int parser_action_row823[] = {
+static int parser_action_row831[] = {
2,
-1, 1, 78,
- 14, 0, 969
+ 14, 0, 977
};
-static int parser_action_row824[] = {
+static int parser_action_row832[] = {
2,
- -1, 3, 823,
- 97, 0, 971
+ -1, 3, 831,
+ 97, 0, 979
};
-static int parser_action_row825[] = {
+static int parser_action_row833[] = {
4,
- -1, 3, 824,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 832,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row826[] = {
+static int parser_action_row834[] = {
2,
-1, 1, 78,
- 14, 0, 969
+ 14, 0, 977
};
-static int parser_action_row827[] = {
+static int parser_action_row835[] = {
2,
-1, 1, 104,
- 59, 0, 974
+ 59, 0, 982
};
-static int parser_action_row828[] = {
+static int parser_action_row836[] = {
1,
-1, 1, 106
};
-static int parser_action_row829[] = {
+static int parser_action_row837[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row830[] = {
+static int parser_action_row838[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row831[] = {
+static int parser_action_row839[] = {
4,
-1, 1, 124,
- 4, 0, 977,
- 14, 0, 978,
- 15, 0, 979
+ 4, 0, 985,
+ 14, 0, 986,
+ 15, 0, 987
};
-static int parser_action_row832[] = {
+static int parser_action_row840[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row833[] = {
+static int parser_action_row841[] = {
1,
-1, 1, 112
};
-static int parser_action_row834[] = {
+static int parser_action_row842[] = {
2,
-1, 1, 108,
- 59, 0, 827
+ 59, 0, 835
};
-static int parser_action_row835[] = {
+static int parser_action_row843[] = {
1,
- -1, 1, 464
+ -1, 1, 466
};
-static int parser_action_row836[] = {
+static int parser_action_row844[] = {
1,
- -1, 1, 466
+ -1, 1, 468
};
-static int parser_action_row837[] = {
+static int parser_action_row845[] = {
22,
- -1, 3, 836,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 97, 0, 833
+ -1, 3, 844,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 97, 0, 841
};
-static int parser_action_row838[] = {
+static int parser_action_row846[] = {
2,
- -1, 1, 459,
- 58, 0, 214
+ -1, 1, 461,
+ 58, 0, 218
};
-static int parser_action_row839[] = {
+static int parser_action_row847[] = {
2,
- -1, 3, 838,
- 58, 0, 215
+ -1, 3, 846,
+ 58, 0, 219
};
-static int parser_action_row840[] = {
+static int parser_action_row848[] = {
7,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 0, 84,
- 54, 0, 985,
+ 28, 0, 86,
+ 54, 0, 993,
95, 0, 3,
- 109, 0, 85
+ 111, 0, 87
};
-static int parser_action_row841[] = {
+static int parser_action_row849[] = {
2,
- -1, 3, 840,
- 96, 0, 995
+ -1, 3, 848,
+ 96, 0, 1003
};
-static int parser_action_row842[] = {
+static int parser_action_row850[] = {
3,
- -1, 3, 841,
- 96, 0, 996,
- 97, 0, 838
+ -1, 3, 849,
+ 96, 0, 1004,
+ 97, 0, 846
};
-static int parser_action_row843[] = {
+static int parser_action_row851[] = {
1,
- -1, 1, 443
+ -1, 1, 445
};
-static int parser_action_row844[] = {
+static int parser_action_row852[] = {
1,
-1, 1, 350
};
-static int parser_action_row845[] = {
+static int parser_action_row853[] = {
1,
-1, 1, 192
};
-static int parser_action_row846[] = {
+static int parser_action_row854[] = {
3,
- -1, 3, 845,
- 31, 0, 998,
- 52, 0, 999
+ -1, 3, 853,
+ 31, 0, 1006,
+ 52, 0, 1007
};
-static int parser_action_row847[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row855[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row848[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row856[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row849[] = {
+static int parser_action_row857[] = {
13,
-1, 1, 332,
- 59, 0, 1002,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 1010,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row850[] = {
+static int parser_action_row858[] = {
1,
-1, 1, 183
};
-static int parser_action_row851[] = {
+static int parser_action_row859[] = {
13,
-1, 1, 330,
- 59, 0, 1004,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 1012,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row852[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row860[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row853[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row861[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 335,
- 59, 0, 1007,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 1015,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 335,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row854[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row862[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row855[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row863[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 339,
- 58, 0, 215,
- 59, 0, 1012,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 1020,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 339,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row856[] = {
+static int parser_action_row864[] = {
3,
- -1, 1, 456,
- 12, 0, 1016,
- 97, 0, 1017
+ -1, 1, 458,
+ 12, 0, 1024,
+ 97, 0, 1025
};
-static int parser_action_row857[] = {
+static int parser_action_row865[] = {
1,
- -1, 1, 398
+ -1, 1, 400
};
-static int parser_action_row858[] = {
+static int parser_action_row866[] = {
1,
- -1, 1, 441
+ -1, 1, 443
};
-static int parser_action_row859[] = {
+static int parser_action_row867[] = {
2,
- -1, 3, 858,
- 53, 0, 1018
+ -1, 3, 866,
+ 53, 0, 1026
};
-static int parser_action_row860[] = {
+static int parser_action_row868[] = {
1,
-1, 1, 219
};
-static int parser_action_row861[] = {
+static int parser_action_row869[] = {
1,
-1, 1, 238
};
-static int parser_action_row862[] = {
+static int parser_action_row870[] = {
1,
-1, 1, 223
};
-static int parser_action_row863[] = {
+static int parser_action_row871[] = {
1,
-1, 1, 242
};
-static int parser_action_row864[] = {
+static int parser_action_row872[] = {
1,
-1, 1, 222
};
-static int parser_action_row865[] = {
+static int parser_action_row873[] = {
1,
-1, 1, 241
};
-static int parser_action_row866[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row874[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row867[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row875[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row868[] = {
+static int parser_action_row876[] = {
1,
- -1, 1, 437
+ -1, 1, 439
};
-static int parser_action_row869[] = {
+static int parser_action_row877[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row870[] = {
+static int parser_action_row878[] = {
3,
- -1, 3, 869,
+ -1, 3, 877,
96, 0, 53,
- 97, 0, 1022
+ 97, 0, 1030
};
-static int parser_action_row871[] = {
+static int parser_action_row879[] = {
2,
- -1, 3, 870,
- 98, 0, 1025
+ -1, 3, 878,
+ 98, 0, 1033
};
-static int parser_action_row872[] = {
+static int parser_action_row880[] = {
1,
-1, 1, 368
};
-static int parser_action_row873[] = {
+static int parser_action_row881[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row874[] = {
+static int parser_action_row882[] = {
1,
- -1, 1, 1084
+ -1, 1, 1092
};
-static int parser_action_row875[] = {
+static int parser_action_row883[] = {
2,
- -1, 1, 445,
- 56, 0, 872
+ -1, 1, 447,
+ 56, 0, 880
};
-static int parser_action_row876[] = {
+static int parser_action_row884[] = {
1,
- -1, 1, 703
+ -1, 1, 707
};
-static int parser_action_row877[] = {
+static int parser_action_row885[] = {
1,
- -1, 1, 765
+ -1, 1, 769
};
-static int parser_action_row878[] = {
+static int parser_action_row886[] = {
3,
- -1, 3, 877,
- 31, 0, 1028,
- 52, 0, 1029
+ -1, 3, 885,
+ 31, 0, 1036,
+ 52, 0, 1037
};
-static int parser_action_row879[] = {
+static int parser_action_row887[] = {
1,
- -1, 1, 747
+ -1, 1, 751
};
-static int parser_action_row880[] = {
+static int parser_action_row888[] = {
1,
- -1, 1, 745
+ -1, 1, 749
};
-static int parser_action_row881[] = {
+static int parser_action_row889[] = {
2,
- -1, 1, 750,
- 52, 0, 277
+ -1, 1, 754,
+ 52, 0, 283
};
-static int parser_action_row882[] = {
+static int parser_action_row890[] = {
3,
- -1, 1, 754,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 758,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row883[] = {
+static int parser_action_row891[] = {
2,
- -1, 1, 456,
- 97, 0, 1032
+ -1, 1, 458,
+ 97, 0, 1040
};
-static int parser_action_row884[] = {
+static int parser_action_row892[] = {
1,
-1, 1, 165
};
-static int parser_action_row885[] = {
+static int parser_action_row893[] = {
1,
-1, 1, 205
};
-static int parser_action_row886[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row894[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row887[] = {
+static int parser_action_row895[] = {
1,
-1, 1, 266
};
-static int parser_action_row888[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row896[] = {
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 353,
73, 1, 353,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row889[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row897[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1035,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1043,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row890[] = {
+static int parser_action_row898[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row891[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row899[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row892[] = {
+static int parser_action_row900[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row893[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row901[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1035,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1043,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row894[] = {
+static int parser_action_row902[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row895[] = {
- 27,
+static int parser_action_row903[] = {
+ 29,
-1, 1, 169,
- 12, 0, 170,
- 22, 0, 171,
- 24, 1, 900,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+ 12, 0, 174,
+ 22, 0, 175,
+ 24, 1, 908,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row896[] = {
+static int parser_action_row904[] = {
3,
-1, 1, 174,
- 24, 1, 905,
- 49, 0, 197
+ 24, 1, 913,
+ 49, 0, 201
};
-static int parser_action_row897[] = {
+static int parser_action_row905[] = {
3,
-1, 1, 171,
- 24, 1, 902,
- 49, 0, 197
+ 24, 1, 910,
+ 49, 0, 201
};
-static int parser_action_row898[] = {
+static int parser_action_row906[] = {
2,
-1, 1, 173,
- 24, 1, 904
+ 24, 1, 912
};
-static int parser_action_row899[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row907[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 200,
+ 97, 0, 204,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row900[] = {
+static int parser_action_row908[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row901[] = {
+static int parser_action_row909[] = {
2,
- -1, 3, 900,
- 11, 0, 1052
+ -1, 3, 908,
+ 11, 0, 1060
};
-static int parser_action_row902[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row910[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 341,
- 58, 0, 215,
- 59, 0, 216,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 220,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 341,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row903[] = {
+static int parser_action_row911[] = {
1,
-1, 1, 259
};
-static int parser_action_row904[] = {
+static int parser_action_row912[] = {
2,
-1, 1, 167,
- 24, 1, 898
+ 24, 1, 906
};
-static int parser_action_row905[] = {
+static int parser_action_row913[] = {
2,
-1, 1, 168,
- 24, 1, 899
+ 24, 1, 907
};
-static int parser_action_row906[] = {
+static int parser_action_row914[] = {
1,
-1, 1, 264
};
-static int parser_action_row907[] = {
+static int parser_action_row915[] = {
3,
- -1, 3, 906,
- 54, 0, 244,
- 73, 0, 1054
+ -1, 3, 914,
+ 54, 0, 250,
+ 73, 0, 1062
};
-static int parser_action_row908[] = {
+static int parser_action_row916[] = {
3,
- -1, 3, 907,
- 41, 0, 1055,
- 98, 0, 255
+ -1, 3, 915,
+ 41, 0, 1063,
+ 98, 0, 261
};
-static int parser_action_row909[] = {
+static int parser_action_row917[] = {
3,
- -1, 1, 455,
- 12, 0, 1056,
- 97, 0, 1057
+ -1, 1, 457,
+ 12, 0, 1064,
+ 97, 0, 1065
};
-static int parser_action_row910[] = {
- 32,
- -1, 1, 458,
- 9, 0, 886,
+static int parser_action_row918[] = {
+ 34,
+ -1, 1, 460,
+ 9, 0, 894,
12, 0, 31,
15, 0, 33,
16, 0, 34,
22, 0, 35,
- 24, 0, 1058,
+ 24, 0, 1066,
25, 0, 36,
26, 0, 37,
27, 0, 38,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row911[] = {
+static int parser_action_row919[] = {
2,
- -1, 3, 910,
- 24, 0, 1062
+ -1, 3, 918,
+ 24, 0, 1070
};
-static int parser_action_row912[] = {
+static int parser_action_row920[] = {
1,
- -1, 1, 907
+ -1, 1, 915
};
-static int parser_action_row913[] = {
+static int parser_action_row921[] = {
1,
- -1, 1, 908
+ -1, 1, 916
};
-static int parser_action_row914[] = {
+static int parser_action_row922[] = {
1,
- -1, 1, 910
+ -1, 1, 918
};
-static int parser_action_row915[] = {
+static int parser_action_row923[] = {
1,
- -1, 1, 909
+ -1, 1, 917
};
-static int parser_action_row916[] = {
+static int parser_action_row924[] = {
1,
- -1, 1, 911
+ -1, 1, 919
};
-static int parser_action_row917[] = {
+static int parser_action_row925[] = {
1,
- -1, 1, 912
+ -1, 1, 920
};
-static int parser_action_row918[] = {
+static int parser_action_row926[] = {
1,
- -1, 1, 913
+ -1, 1, 921
};
-static int parser_action_row919[] = {
+static int parser_action_row927[] = {
4,
- -1, 1, 457,
- 12, 0, 1063,
+ -1, 1, 459,
+ 12, 0, 1071,
96, 0, 53,
- 97, 0, 1064
+ 97, 0, 1072
};
-static int parser_action_row920[] = {
+static int parser_action_row928[] = {
1,
-1, 1, 270
};
-static int parser_action_row921[] = {
+static int parser_action_row929[] = {
2,
- -1, 3, 920,
- 49, 0, 197
+ -1, 3, 928,
+ 49, 0, 201
};
-static int parser_action_row922[] = {
+static int parser_action_row930[] = {
2,
- -1, 3, 921,
- 53, 0, 1067
+ -1, 3, 929,
+ 53, 0, 1075
};
-static int parser_action_row923[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row931[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row924[] = {
+static int parser_action_row932[] = {
1,
- -1, 1, 450
+ -1, 1, 452
};
-static int parser_action_row925[] = {
+static int parser_action_row933[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row926[] = {
+static int parser_action_row934[] = {
2,
- -1, 3, 925,
- 98, 0, 1070
+ -1, 3, 933,
+ 98, 0, 1078
};
-static int parser_action_row927[] = {
+static int parser_action_row935[] = {
1,
-1, 1, 288
};
-static int parser_action_row928[] = {
+static int parser_action_row936[] = {
1,
-1, 1, 332
};
-static int parser_action_row929[] = {
+static int parser_action_row937[] = {
1,
-1, 1, 330
};
-static int parser_action_row930[] = {
+static int parser_action_row938[] = {
2,
-1, 1, 335,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row931[] = {
+static int parser_action_row939[] = {
3,
-1, 1, 339,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row932[] = {
+static int parser_action_row940[] = {
2,
- -1, 1, 456,
- 97, 0, 1073
+ -1, 1, 458,
+ 97, 0, 1081
};
-static int parser_action_row933[] = {
+static int parser_action_row941[] = {
3,
- -1, 3, 932,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 940,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row934[] = {
+static int parser_action_row942[] = {
2,
-1, 1, 150,
- 56, 0, 1075
+ 56, 0, 1083
};
-static int parser_action_row935[] = {
+static int parser_action_row943[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row936[] = {
+static int parser_action_row944[] = {
2,
-1, 1, 30,
13, 0, 32
};
-static int parser_action_row937[] = {
+static int parser_action_row945[] = {
4,
- -1, 3, 936,
- 6, 0, 792,
- 17, 0, 793,
- 97, 0, 794
+ -1, 3, 944,
+ 6, 0, 800,
+ 17, 0, 801,
+ 97, 0, 802
};
-static int parser_action_row938[] = {
+static int parser_action_row946[] = {
3,
-1, 1, 356,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row939[] = {
+static int parser_action_row947[] = {
2,
- -1, 3, 938,
- 97, 0, 1082
+ -1, 3, 946,
+ 97, 0, 1090
};
-static int parser_action_row940[] = {
+static int parser_action_row948[] = {
3,
- -1, 3, 939,
+ -1, 3, 947,
96, 0, 53,
- 97, 0, 1083
+ 97, 0, 1091
};
-static int parser_action_row941[] = {
+static int parser_action_row949[] = {
4,
- -1, 3, 940,
- 6, 0, 792,
- 17, 0, 793,
- 97, 0, 794
+ -1, 3, 948,
+ 6, 0, 800,
+ 17, 0, 801,
+ 97, 0, 802
};
-static int parser_action_row942[] = {
+static int parser_action_row950[] = {
2,
- -1, 3, 941,
- 53, 0, 1086
+ -1, 3, 949,
+ 53, 0, 1094
};
-static int parser_action_row943[] = {
+static int parser_action_row951[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row944[] = {
+static int parser_action_row952[] = {
1,
- -1, 1, 1080
+ -1, 1, 1088
};
-static int parser_action_row945[] = {
+static int parser_action_row953[] = {
2,
- -1, 1, 409,
- 56, 0, 942
+ -1, 1, 411,
+ 56, 0, 950
};
-static int parser_action_row946[] = {
+static int parser_action_row954[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row947[] = {
+static int parser_action_row955[] = {
1,
- -1, 1, 406
+ -1, 1, 408
};
-static int parser_action_row948[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row956[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row949[] = {
+static int parser_action_row957[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row950[] = {
+static int parser_action_row958[] = {
1,
-1, 1, 274
};
-static int parser_action_row951[] = {
+static int parser_action_row959[] = {
2,
- -1, 3, 950,
- 49, 0, 197
+ -1, 3, 958,
+ 49, 0, 201
};
-static int parser_action_row952[] = {
+static int parser_action_row960[] = {
3,
- -1, 3, 951,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 959,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row953[] = {
+static int parser_action_row961[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row954[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row962[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row955[] = {
+static int parser_action_row963[] = {
15,
-1, 1, 333,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1096,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1104,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row956[] = {
+static int parser_action_row964[] = {
22,
- -1, 1, 455,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1097
+ -1, 1, 457,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1105
};
-static int parser_action_row957[] = {
+static int parser_action_row965[] = {
1,
- -1, 1, 431
+ -1, 1, 433
};
-static int parser_action_row958[] = {
+static int parser_action_row966[] = {
23,
- -1, 1, 457,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 1098
+ -1, 1, 459,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 1106
};
-static int parser_action_row959[] = {
+static int parser_action_row967[] = {
1,
- -1, 1, 384
+ -1, 1, 386
};
-static int parser_action_row960[] = {
+static int parser_action_row968[] = {
1,
- -1, 1, 386
+ -1, 1, 388
};
-static int parser_action_row961[] = {
+static int parser_action_row969[] = {
1,
- -1, 1, 383
+ -1, 1, 385
};
-static int parser_action_row962[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row970[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row963[] = {
+static int parser_action_row971[] = {
2,
- -1, 3, 962,
- 23, 0, 1100
+ -1, 3, 970,
+ 23, 0, 1108
};
-static int parser_action_row964[] = {
+static int parser_action_row972[] = {
2,
- -1, 3, 963,
- 28, 0, 1101
+ -1, 3, 971,
+ 28, 0, 1109
};
-static int parser_action_row965[] = {
- 23,
- -1, 1, 458,
- 12, 0, 1102,
- 22, 0, 1103,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row973[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 22, 0, 1111,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row966[] = {
+static int parser_action_row974[] = {
1,
- -1, 1, 382
+ -1, 1, 384
};
-static int parser_action_row967[] = {
+static int parser_action_row975[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row968[] = {
+static int parser_action_row976[] = {
1,
- -1, 1, 389
+ -1, 1, 391
};
-static int parser_action_row969[] = {
+static int parser_action_row977[] = {
2,
- -1, 3, 968,
- 97, 0, 1142
+ -1, 3, 976,
+ 97, 0, 1152
};
-static int parser_action_row970[] = {
+static int parser_action_row978[] = {
5,
-1, 1, 30,
- 0, 0, 88,
- 1, 0, 89,
+ 0, 0, 90,
+ 1, 0, 91,
13, 0, 32,
- 95, 0, 90
+ 95, 0, 92
};
-static int parser_action_row971[] = {
+static int parser_action_row979[] = {
4,
- -1, 3, 970,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 978,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row972[] = {
+static int parser_action_row980[] = {
2,
- -1, 1, 452,
- 58, 0, 215
+ -1, 1, 454,
+ 58, 0, 219
};
-static int parser_action_row973[] = {
+static int parser_action_row981[] = {
1,
-1, 1, 18
};
-static int parser_action_row974[] = {
+static int parser_action_row982[] = {
4,
- -1, 3, 973,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 981,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row975[] = {
+static int parser_action_row983[] = {
1,
-1, 1, 107
};
-static int parser_action_row976[] = {
+static int parser_action_row984[] = {
2,
-1, 1, 115,
- 97, 0, 1148
+ 97, 0, 1158
};
-static int parser_action_row977[] = {
+static int parser_action_row985[] = {
3,
- -1, 3, 976,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 984,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row978[] = {
+static int parser_action_row986[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row979[] = {
+static int parser_action_row987[] = {
5,
-1, 1, 30,
- 0, 0, 88,
- 1, 0, 89,
+ 0, 0, 90,
+ 1, 0, 91,
13, 0, 32,
- 95, 0, 90
+ 95, 0, 92
};
-static int parser_action_row980[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row988[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row981[] = {
+static int parser_action_row989[] = {
3,
-1, 1, 124,
- 4, 0, 977,
- 15, 0, 1156
+ 4, 0, 985,
+ 15, 0, 1166
};
-static int parser_action_row982[] = {
+static int parser_action_row990[] = {
3,
- -1, 3, 981,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 989,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row983[] = {
+static int parser_action_row991[] = {
1,
- -1, 1, 493
+ -1, 1, 495
};
-static int parser_action_row984[] = {
+static int parser_action_row992[] = {
1,
-1, 1, 111
};
-static int parser_action_row985[] = {
+static int parser_action_row993[] = {
1,
- -1, 1, 465
+ -1, 1, 467
};
-static int parser_action_row986[] = {
+static int parser_action_row994[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row987[] = {
+static int parser_action_row995[] = {
2,
-1, 1, 75,
9, 1, 45
};
-static int parser_action_row988[] = {
+static int parser_action_row996[] = {
2,
- -1, 3, 987,
- 9, 0, 1160
+ -1, 3, 995,
+ 9, 0, 1170
};
-static int parser_action_row989[] = {
+static int parser_action_row997[] = {
1,
- -1, 1, 1062
+ -1, 1, 1070
};
-static int parser_action_row990[] = {
+static int parser_action_row998[] = {
4,
- -1, 3, 989,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 997,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row991[] = {
+static int parser_action_row999[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row992[] = {
+static int parser_action_row1000[] = {
1,
-1, 1, 74
};
-static int parser_action_row993[] = {
+static int parser_action_row1001[] = {
1,
- -1, 1, 486
+ -1, 1, 488
};
-static int parser_action_row994[] = {
+static int parser_action_row1002[] = {
5,
-1, 1, 30,
- 6, 0, 1163,
+ 6, 0, 1173,
9, 1, 46,
13, 0, 32,
- 97, 0, 1164
+ 97, 0, 1174
};
-static int parser_action_row995[] = {
+static int parser_action_row1003[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 9, 1, 487,
+ 9, 1, 489,
95, 0, 3
};
-static int parser_action_row996[] = {
+static int parser_action_row1004[] = {
1,
- -1, 1, 460
+ -1, 1, 462
};
-static int parser_action_row997[] = {
+static int parser_action_row1005[] = {
2,
- -1, 1, 462,
- 58, 0, 214
+ -1, 1, 464,
+ 58, 0, 218
};
-static int parser_action_row998[] = {
+static int parser_action_row1006[] = {
2,
- -1, 3, 997,
- 96, 0, 1171
+ -1, 3, 1005,
+ 96, 0, 1181
};
-static int parser_action_row999[] = {
+static int parser_action_row1007[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1000[] = {
+static int parser_action_row1008[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1001[] = {
+static int parser_action_row1009[] = {
1,
-1, 1, 210
};
-static int parser_action_row1002[] = {
+static int parser_action_row1010[] = {
1,
-1, 1, 229
};
-static int parser_action_row1003[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1011[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1004[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1012[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1005[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1013[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1006[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1014[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1007[] = {
+static int parser_action_row1015[] = {
1,
-1, 1, 194
};
-static int parser_action_row1008[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1016[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1009[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1017[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1010[] = {
+static int parser_action_row1018[] = {
13,
-1, 1, 334,
- 59, 0, 1180,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 1190,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1011[] = {
+static int parser_action_row1019[] = {
1,
-1, 1, 184
};
-static int parser_action_row1012[] = {
+static int parser_action_row1020[] = {
1,
-1, 1, 196
};
-static int parser_action_row1013[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1021[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1014[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1022[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1015[] = {
+static int parser_action_row1023[] = {
13,
-1, 1, 338,
- 59, 0, 1184,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 1194,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1016[] = {
+static int parser_action_row1024[] = {
1,
-1, 1, 186
};
-static int parser_action_row1017[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1025[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1018[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1026[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 337,
- 59, 0, 1187,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 1197,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 337,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1019[] = {
+static int parser_action_row1027[] = {
1,
- -1, 1, 439
+ -1, 1, 441
};
-static int parser_action_row1020[] = {
+static int parser_action_row1028[] = {
1,
-1, 1, 221
};
-static int parser_action_row1021[] = {
+static int parser_action_row1029[] = {
1,
-1, 1, 240
};
-static int parser_action_row1022[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1030[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1023[] = {
+static int parser_action_row1031[] = {
3,
- -1, 1, 771,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 775,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1024[] = {
+static int parser_action_row1032[] = {
2,
- -1, 3, 1023,
- 97, 0, 1193
+ -1, 3, 1031,
+ 97, 0, 1203
};
-static int parser_action_row1025[] = {
+static int parser_action_row1033[] = {
3,
- -1, 3, 1024,
+ -1, 3, 1032,
96, 0, 53,
- 97, 0, 1194
+ 97, 0, 1204
};
-static int parser_action_row1026[] = {
+static int parser_action_row1034[] = {
3,
- -1, 1, 742,
- 54, 1, 745,
- 73, 1, 745
+ -1, 1, 746,
+ 54, 1, 749,
+ 73, 1, 749
};
-static int parser_action_row1027[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1035[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 513,
+ 97, 0, 521,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1028[] = {
+static int parser_action_row1036[] = {
1,
- -1, 1, 1085
+ -1, 1, 1093
};
-static int parser_action_row1029[] = {
+static int parser_action_row1037[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1030[] = {
+static int parser_action_row1038[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1031[] = {
+static int parser_action_row1039[] = {
1,
- -1, 1, 749
+ -1, 1, 753
};
-static int parser_action_row1032[] = {
+static int parser_action_row1040[] = {
1,
- -1, 1, 753
+ -1, 1, 757
};
-static int parser_action_row1033[] = {
+static int parser_action_row1041[] = {
2,
- -1, 1, 752,
- 52, 0, 277
+ -1, 1, 756,
+ 52, 0, 283
};
-static int parser_action_row1034[] = {
+static int parser_action_row1042[] = {
1,
-1, 1, 206
};
-static int parser_action_row1035[] = {
+static int parser_action_row1043[] = {
2,
-1, 1, 193,
- 24, 1, 924
+ 24, 1, 932
};
-static int parser_action_row1036[] = {
+static int parser_action_row1044[] = {
3,
-1, 1, 158,
- 24, 1, 896,
- 49, 1, 981
+ 24, 1, 904,
+ 49, 1, 989
};
-static int parser_action_row1037[] = {
- 31,
- -1, 1, 458,
- 9, 0, 1200,
+static int parser_action_row1045[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 1210,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1038[] = {
+static int parser_action_row1046[] = {
1,
- -1, 1, 933
+ -1, 1, 941
};
-static int parser_action_row1039[] = {
+static int parser_action_row1047[] = {
1,
- -1, 1, 897
+ -1, 1, 905
};
-static int parser_action_row1040[] = {
+static int parser_action_row1048[] = {
2,
- -1, 3, 1039,
- 49, 0, 197
+ -1, 3, 1047,
+ 49, 0, 201
};
-static int parser_action_row1041[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1049[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1042[] = {
+static int parser_action_row1050[] = {
1,
-1, 1, 261
};
-static int parser_action_row1043[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1051[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1044[] = {
+static int parser_action_row1052[] = {
1,
- -1, 1, 936
+ -1, 1, 944
};
-static int parser_action_row1045[] = {
+static int parser_action_row1053[] = {
2,
- -1, 3, 1044,
- 49, 0, 197
+ -1, 3, 1052,
+ 49, 0, 201
};
-static int parser_action_row1046[] = {
+static int parser_action_row1054[] = {
3,
- -1, 3, 1045,
- 52, 0, 340,
- 97, 0, 341
+ -1, 3, 1053,
+ 52, 0, 348,
+ 97, 0, 349
};
-static int parser_action_row1047[] = {
+static int parser_action_row1055[] = {
2,
-1, 1, 170,
- 24, 1, 901
+ 24, 1, 909
};
-static int parser_action_row1048[] = {
+static int parser_action_row1056[] = {
2,
-1, 1, 175,
- 24, 1, 906
+ 24, 1, 914
};
-static int parser_action_row1049[] = {
+static int parser_action_row1057[] = {
2,
-1, 1, 172,
- 24, 1, 903
+ 24, 1, 911
};
-static int parser_action_row1050[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1058[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1051[] = {
+static int parser_action_row1059[] = {
2,
-1, 1, 280,
- 24, 0, 1208
+ 24, 0, 1218
};
-static int parser_action_row1052[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1060[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 393,
+ 97, 0, 401,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1053[] = {
+static int parser_action_row1061[] = {
3,
- -1, 3, 1052,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1060,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1054[] = {
+static int parser_action_row1062[] = {
2,
-1, 1, 187,
- 24, 1, 918
+ 24, 1, 926
};
-static int parser_action_row1055[] = {
+static int parser_action_row1063[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1056[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1064[] = {
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 349,
73, 1, 349,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1057[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1065[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1058[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1066[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 343,
- 59, 0, 488,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 496,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 343,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1059[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1067[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1060[] = {
+static int parser_action_row1068[] = {
3,
- -1, 3, 1059,
- 9, 0, 886,
- 24, 0, 1216
+ -1, 3, 1067,
+ 9, 0, 894,
+ 24, 0, 1226
};
-static int parser_action_row1061[] = {
+static int parser_action_row1069[] = {
4,
- -1, 3, 1060,
+ -1, 3, 1068,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1062[] = {
+static int parser_action_row1070[] = {
1,
-1, 1, 265
};
-static int parser_action_row1063[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1071[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1064[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1072[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1065[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1073[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 347,
- 58, 0, 215,
- 59, 0, 493,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 501,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 347,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1066[] = {
+static int parser_action_row1074[] = {
3,
- -1, 1, 456,
- 12, 0, 1222,
- 97, 0, 1223
+ -1, 1, 458,
+ 12, 0, 1232,
+ 97, 0, 1233
};
-static int parser_action_row1067[] = {
+static int parser_action_row1075[] = {
1,
-1, 1, 269
};
-static int parser_action_row1068[] = {
+static int parser_action_row1076[] = {
1,
- -1, 1, 447
+ -1, 1, 449
};
-static int parser_action_row1069[] = {
+static int parser_action_row1077[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1070[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1078[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1071[] = {
+static int parser_action_row1079[] = {
3,
-1, 1, 327,
54, 1, 330,
73, 1, 330
};
-static int parser_action_row1072[] = {
+static int parser_action_row1080[] = {
1,
-1, 1, 334
};
-static int parser_action_row1073[] = {
+static int parser_action_row1081[] = {
1,
-1, 1, 338
};
-static int parser_action_row1074[] = {
+static int parser_action_row1082[] = {
2,
-1, 1, 337,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row1075[] = {
+static int parser_action_row1083[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1076[] = {
+static int parser_action_row1084[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1077[] = {
+static int parser_action_row1085[] = {
1,
- -1, 1, 1070
+ -1, 1, 1078
};
-static int parser_action_row1078[] = {
+static int parser_action_row1086[] = {
2,
-1, 1, 151,
- 56, 0, 1075
+ 56, 0, 1083
};
-static int parser_action_row1079[] = {
+static int parser_action_row1087[] = {
2,
- -1, 3, 1078,
- 55, 0, 1230
+ -1, 3, 1086,
+ 55, 0, 1240
};
-static int parser_action_row1080[] = {
+static int parser_action_row1088[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1081[] = {
+static int parser_action_row1089[] = {
2,
- -1, 1, 797,
- 94, 0, 594
+ -1, 1, 803,
+ 94, 0, 602
};
-static int parser_action_row1082[] = {
+static int parser_action_row1090[] = {
1,
-1, 1, 355
};
-static int parser_action_row1083[] = {
+static int parser_action_row1091[] = {
2,
-1, 1, 358,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row1084[] = {
+static int parser_action_row1092[] = {
3,
-1, 1, 362,
- 52, 0, 277,
- 58, 0, 215
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1085[] = {
+static int parser_action_row1093[] = {
2,
- -1, 3, 1084,
- 97, 0, 1235
+ -1, 3, 1092,
+ 97, 0, 1245
};
-static int parser_action_row1086[] = {
- 13,
- -1, 1, 405,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 52, 0, 1236,
- 94, 0, 204,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1094[] = {
+ 15,
+ -1, 1, 407,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 52, 0, 1246,
+ 94, 0, 208,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1087[] = {
+static int parser_action_row1095[] = {
1,
- -1, 1, 403
+ -1, 1, 405
};
-static int parser_action_row1088[] = {
+static int parser_action_row1096[] = {
2,
-1, 1, 30,
13, 0, 32
};
-static int parser_action_row1089[] = {
+static int parser_action_row1097[] = {
1,
- -1, 1, 1081
+ -1, 1, 1089
};
-static int parser_action_row1090[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row1098[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1091[] = {
+static int parser_action_row1099[] = {
1,
-1, 1, 275
};
-static int parser_action_row1092[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1100[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1093[] = {
+static int parser_action_row1101[] = {
1,
-1, 1, 273
};
-static int parser_action_row1094[] = {
+static int parser_action_row1102[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1095[] = {
+static int parser_action_row1103[] = {
2,
- -1, 3, 1094,
- 55, 0, 1245
+ -1, 3, 1102,
+ 55, 0, 1255
};
-static int parser_action_row1096[] = {
+static int parser_action_row1104[] = {
1,
- -1, 1, 1000
+ -1, 1, 1008
};
-static int parser_action_row1097[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1105[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1098[] = {
+static int parser_action_row1106[] = {
14,
-1, 1, 335,
- 52, 0, 277,
- 59, 0, 1246,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 59, 0, 1256,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1099[] = {
+static int parser_action_row1107[] = {
15,
-1, 1, 339,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1247,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1257,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1100[] = {
+static int parser_action_row1108[] = {
22,
- -1, 1, 456,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1248
+ -1, 1, 458,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1258
};
-static int parser_action_row1101[] = {
+static int parser_action_row1109[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1102[] = {
+static int parser_action_row1110[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1103[] = {
+static int parser_action_row1111[] = {
2,
- -1, 1, 596,
- 52, 0, 277
+ -1, 1, 598,
+ 52, 0, 283
};
-static int parser_action_row1104[] = {
+static int parser_action_row1112[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1105[] = {
+static int parser_action_row1113[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1106[] = {
+static int parser_action_row1114[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1107[] = {
+static int parser_action_row1115[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1108[] = {
+static int parser_action_row1116[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1109[] = {
+static int parser_action_row1117[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1110[] = {
+static int parser_action_row1118[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1111[] = {
+static int parser_action_row1119[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1112[] = {
- 16,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1260,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
+static int parser_action_row1120[] = {
+ 18,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1270,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
52, 0, 51,
96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1113[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1121[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1114[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1122[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1115[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1123[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1116[] = {
+static int parser_action_row1124[] = {
3,
- -1, 1, 578,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 580,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1117[] = {
+static int parser_action_row1125[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1118[] = {
+static int parser_action_row1126[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1119[] = {
+static int parser_action_row1127[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1120[] = {
+static int parser_action_row1128[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1121[] = {
+static int parser_action_row1129[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1122[] = {
+static int parser_action_row1130[] = {
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
+};
+static int parser_action_row1131[] = {
+ 2,
+ -1, 1, 407,
+ 94, 0, 208
+};
+static int parser_action_row1132[] = {
1,
- -1, 1, 621
+ -1, 1, 625
};
-static int parser_action_row1123[] = {
+static int parser_action_row1133[] = {
1,
- -1, 1, 620
+ -1, 1, 624
};
-static int parser_action_row1124[] = {
+static int parser_action_row1134[] = {
3,
- -1, 3, 1123,
- 41, 0, 1272,
- 98, 0, 1273
+ -1, 3, 1133,
+ 41, 0, 1284,
+ 98, 0, 1285
};
-static int parser_action_row1125[] = {
+static int parser_action_row1135[] = {
2,
- -1, 1, 455,
- 97, 0, 1274
+ -1, 1, 457,
+ 97, 0, 1286
};
-static int parser_action_row1126[] = {
+static int parser_action_row1136[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1127[] = {
+static int parser_action_row1137[] = {
4,
- -1, 1, 526,
- 29, 0, 1276,
- 30, 0, 1277,
- 32, 0, 1278
+ -1, 1, 528,
+ 29, 0, 1288,
+ 30, 0, 1289,
+ 32, 0, 1290
};
-static int parser_action_row1128[] = {
+static int parser_action_row1138[] = {
1,
- -1, 1, 528
+ -1, 1, 530
};
-static int parser_action_row1129[] = {
+static int parser_action_row1139[] = {
1,
- -1, 1, 533
+ -1, 1, 535
};
-static int parser_action_row1130[] = {
+static int parser_action_row1140[] = {
10,
- -1, 1, 535,
- 39, 0, 1279,
- 80, 0, 1280,
- 84, 0, 1281,
- 85, 0, 1282,
- 86, 0, 1283,
- 87, 0, 1284,
- 89, 0, 1285,
- 90, 0, 1286,
- 92, 0, 1287
-};
-static int parser_action_row1131[] = {
- 2,
- -1, 1, 544,
- 81, 0, 1288
+ -1, 1, 537,
+ 39, 0, 1291,
+ 80, 0, 1292,
+ 84, 0, 1293,
+ 85, 0, 1294,
+ 86, 0, 1295,
+ 87, 0, 1296,
+ 89, 0, 1297,
+ 90, 0, 1298,
+ 92, 0, 1299
};
-static int parser_action_row1132[] = {
+static int parser_action_row1141[] = {
2,
-1, 1, 546,
- 82, 0, 1289
+ 81, 0, 1300
};
-static int parser_action_row1133[] = {
- 3,
+static int parser_action_row1142[] = {
+ 2,
-1, 1, 548,
- 88, 0, 1290,
- 91, 0, 1291
+ 82, 0, 1301
};
-static int parser_action_row1134[] = {
+static int parser_action_row1143[] = {
3,
-1, 1, 550,
- 74, 0, 1292,
- 75, 0, 1293
+ 88, 0, 1302,
+ 91, 0, 1303
};
-static int parser_action_row1135[] = {
+static int parser_action_row1144[] = {
+ 3,
+ -1, 1, 552,
+ 74, 0, 1304,
+ 75, 0, 1305
+};
+static int parser_action_row1145[] = {
4,
- -1, 1, 553,
- 76, 0, 1294,
- 78, 0, 1295,
- 79, 0, 1296
+ -1, 1, 555,
+ 76, 0, 1306,
+ 78, 0, 1307,
+ 79, 0, 1308
};
-static int parser_action_row1136[] = {
+static int parser_action_row1146[] = {
1,
- -1, 1, 556
+ -1, 1, 558
};
-static int parser_action_row1137[] = {
+static int parser_action_row1147[] = {
2,
- -1, 1, 560,
- 77, 0, 1297
+ -1, 1, 562,
+ 77, 0, 1309
};
-static int parser_action_row1138[] = {
+static int parser_action_row1148[] = {
1,
- -1, 1, 562
+ -1, 1, 564
};
-static int parser_action_row1139[] = {
+static int parser_action_row1149[] = {
2,
- -1, 1, 567,
- 73, 0, 1298
+ -1, 1, 569,
+ 73, 0, 1310
};
-static int parser_action_row1140[] = {
+static int parser_action_row1150[] = {
1,
- -1, 1, 572
+ -1, 1, 574
};
-static int parser_action_row1141[] = {
+static int parser_action_row1151[] = {
3,
- -1, 1, 457,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 1299
+ 97, 0, 1311
};
-static int parser_action_row1142[] = {
+static int parser_action_row1152[] = {
1,
- -1, 1, 390
+ -1, 1, 392
};
-static int parser_action_row1143[] = {
+static int parser_action_row1153[] = {
2,
- -1, 1, 453,
- 58, 0, 215
+ -1, 1, 455,
+ 58, 0, 219
};
-static int parser_action_row1144[] = {
+static int parser_action_row1154[] = {
2,
- -1, 3, 1143,
- 97, 0, 1301
+ -1, 3, 1153,
+ 97, 0, 1313
};
-static int parser_action_row1145[] = {
+static int parser_action_row1155[] = {
1,
-1, 1, 76
};
-static int parser_action_row1146[] = {
+static int parser_action_row1156[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1147[] = {
+static int parser_action_row1157[] = {
1,
-1, 1, 16
};
-static int parser_action_row1148[] = {
+static int parser_action_row1158[] = {
1,
-1, 1, 17
};
-static int parser_action_row1149[] = {
+static int parser_action_row1159[] = {
3,
- -1, 1, 405,
- 57, 0, 829,
- 94, 0, 204
+ -1, 1, 407,
+ 57, 0, 837,
+ 94, 0, 208
};
-static int parser_action_row1150[] = {
+static int parser_action_row1160[] = {
2,
- -1, 3, 1149,
- 53, 0, 1308
+ -1, 3, 1159,
+ 53, 0, 1320
};
-static int parser_action_row1151[] = {
+static int parser_action_row1161[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 56, 0, 1309
+ 56, 0, 1321
};
-static int parser_action_row1152[] = {
+static int parser_action_row1162[] = {
1,
-1, 1, 153
};
-static int parser_action_row1153[] = {
+static int parser_action_row1163[] = {
25,
- -1, 3, 1152,
- 41, 0, 1313,
- 47, 0, 396,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 424,
- 97, 0, 660
+ -1, 3, 1162,
+ 41, 0, 1325,
+ 47, 0, 404,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 432,
+ 97, 0, 668
};
-static int parser_action_row1154[] = {
+static int parser_action_row1164[] = {
4,
-1, 1, 79,
- 0, 1, 496,
- 1, 1, 496,
- 95, 1, 496
+ 0, 1, 498,
+ 1, 1, 498,
+ 95, 1, 498
};
-static int parser_action_row1155[] = {
+static int parser_action_row1165[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1156[] = {
+static int parser_action_row1166[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1157[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1167[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1158[] = {
+static int parser_action_row1168[] = {
3,
- -1, 3, 1157,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1167,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1159[] = {
+static int parser_action_row1169[] = {
1,
- -1, 1, 494
+ -1, 1, 496
};
-static int parser_action_row1160[] = {
+static int parser_action_row1170[] = {
2,
-1, 1, 39,
- 96, 0, 1324
+ 96, 0, 1336
};
-static int parser_action_row1161[] = {
+static int parser_action_row1171[] = {
1,
-1, 1, 26
};
-static int parser_action_row1162[] = {
+static int parser_action_row1172[] = {
1,
-1, 1, 47
};
-static int parser_action_row1163[] = {
+static int parser_action_row1173[] = {
2,
- -1, 3, 1162,
- 9, 0, 1327
+ -1, 3, 1172,
+ 9, 0, 1339
};
-static int parser_action_row1164[] = {
+static int parser_action_row1174[] = {
1,
- -1, 1, 1050
+ -1, 1, 1058
};
-static int parser_action_row1165[] = {
+static int parser_action_row1175[] = {
1,
- -1, 1, 1049
+ -1, 1, 1057
};
-static int parser_action_row1166[] = {
+static int parser_action_row1176[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row1167[] = {
- 56,
- -1, 1, 420,
- 12, 0, 116,
+static int parser_action_row1177[] = {
+ 58,
+ -1, 1, 422,
+ 12, 0, 118,
15, 0, 33,
16, 0, 34,
- 22, 0, 117,
+ 22, 0, 119,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 118,
- 33, 0, 1329,
- 34, 0, 1330,
- 35, 0, 1331,
- 36, 0, 1332,
+ 31, 0, 120,
+ 33, 0, 1341,
+ 34, 0, 1342,
+ 35, 0, 1343,
+ 36, 0, 1344,
37, 0, 43,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 47, 0, 396,
- 48, 0, 125,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 47, 0, 404,
+ 48, 0, 127,
50, 0, 49,
- 51, 0, 1333,
- 52, 0, 1334,
- 54, 0, 619,
- 74, 0, 1335,
- 75, 0, 1336,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 1337,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 1338,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 51, 0, 1345,
+ 52, 0, 1346,
+ 54, 0, 627,
+ 74, 0, 1347,
+ 75, 0, 1348,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 1349,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 1350,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1168[] = {
+static int parser_action_row1178[] = {
1,
-1, 1, 75
};
-static int parser_action_row1169[] = {
+static int parser_action_row1179[] = {
1,
- -1, 1, 1063
+ -1, 1, 1071
};
-static int parser_action_row1170[] = {
+static int parser_action_row1180[] = {
4,
-1, 1, 30,
- 6, 0, 1163,
+ 6, 0, 1173,
13, 0, 32,
- 97, 0, 1164
+ 97, 0, 1174
};
-static int parser_action_row1171[] = {
+static int parser_action_row1181[] = {
1,
-1, 1, 44
};
-static int parser_action_row1172[] = {
+static int parser_action_row1182[] = {
1,
- -1, 1, 461
+ -1, 1, 463
};
-static int parser_action_row1173[] = {
+static int parser_action_row1183[] = {
2,
- -1, 3, 1172,
- 45, 0, 1358
+ -1, 3, 1182,
+ 45, 0, 1370
};
-static int parser_action_row1174[] = {
+static int parser_action_row1184[] = {
4,
- -1, 3, 1173,
- 31, 0, 1359,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1183,
+ 31, 0, 1371,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1175[] = {
+static int parser_action_row1185[] = {
1,
-1, 1, 209
};
-static int parser_action_row1176[] = {
+static int parser_action_row1186[] = {
1,
-1, 1, 228
};
-static int parser_action_row1177[] = {
+static int parser_action_row1187[] = {
1,
-1, 1, 207
};
-static int parser_action_row1178[] = {
+static int parser_action_row1188[] = {
1,
-1, 1, 226
};
-static int parser_action_row1179[] = {
+static int parser_action_row1189[] = {
1,
-1, 1, 212
};
-static int parser_action_row1180[] = {
+static int parser_action_row1190[] = {
1,
-1, 1, 231
};
-static int parser_action_row1181[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1191[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1182[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1192[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1183[] = {
+static int parser_action_row1193[] = {
1,
-1, 1, 216
};
-static int parser_action_row1184[] = {
+static int parser_action_row1194[] = {
1,
-1, 1, 235
};
-static int parser_action_row1185[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1195[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1186[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1196[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1187[] = {
+static int parser_action_row1197[] = {
1,
-1, 1, 195
};
-static int parser_action_row1188[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1198[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1189[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1199[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1190[] = {
+static int parser_action_row1200[] = {
13,
-1, 1, 336,
- 59, 0, 1367,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 59, 0, 1379,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1191[] = {
+static int parser_action_row1201[] = {
1,
-1, 1, 185
};
-static int parser_action_row1192[] = {
+static int parser_action_row1202[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1193[] = {
+static int parser_action_row1203[] = {
1,
- -1, 1, 770
+ -1, 1, 774
};
-static int parser_action_row1194[] = {
+static int parser_action_row1204[] = {
2,
- -1, 1, 773,
- 52, 0, 277
+ -1, 1, 777,
+ 52, 0, 283
};
-static int parser_action_row1195[] = {
+static int parser_action_row1205[] = {
3,
- -1, 1, 777,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 781,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1196[] = {
+static int parser_action_row1206[] = {
2,
- -1, 3, 1195,
- 97, 0, 1372
+ -1, 3, 1205,
+ 97, 0, 1384
};
-static int parser_action_row1197[] = {
+static int parser_action_row1207[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1198[] = {
+static int parser_action_row1208[] = {
2,
- -1, 3, 1197,
- 45, 0, 1374
+ -1, 3, 1207,
+ 45, 0, 1386
};
-static int parser_action_row1199[] = {
+static int parser_action_row1209[] = {
4,
- -1, 3, 1198,
- 31, 0, 1375,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1208,
+ 31, 0, 1387,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1200[] = {
+static int parser_action_row1210[] = {
1,
- -1, 1, 751
+ -1, 1, 755
};
-static int parser_action_row1201[] = {
+static int parser_action_row1211[] = {
3,
-1, 1, 157,
- 24, 1, 895,
- 49, 1, 980
+ 24, 1, 903,
+ 49, 1, 988
};
-static int parser_action_row1202[] = {
+static int parser_action_row1212[] = {
3,
-1, 1, 156,
- 24, 1, 894,
- 49, 1, 979
+ 24, 1, 902,
+ 49, 1, 987
};
-static int parser_action_row1203[] = {
+static int parser_action_row1213[] = {
2,
-1, 1, 256,
- 24, 1, 932
+ 24, 1, 940
};
-static int parser_action_row1204[] = {
+static int parser_action_row1214[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1205[] = {
+static int parser_action_row1215[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1206[] = {
+static int parser_action_row1216[] = {
2,
-1, 1, 267,
- 24, 1, 935
+ 24, 1, 943
};
-static int parser_action_row1207[] = {
+static int parser_action_row1217[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1208[] = {
+static int parser_action_row1218[] = {
2,
-1, 1, 281,
- 24, 0, 1380
+ 24, 0, 1392
};
-static int parser_action_row1209[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1219[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1381,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1393,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1210[] = {
+static int parser_action_row1220[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1211[] = {
+static int parser_action_row1221[] = {
2,
- -1, 3, 1210,
- 57, 0, 1385
+ -1, 3, 1220,
+ 57, 0, 1397
};
-static int parser_action_row1212[] = {
+static int parser_action_row1222[] = {
5,
- -1, 1, 458,
- 12, 0, 1386,
- 46, 0, 669,
+ -1, 1, 460,
+ 12, 0, 1398,
+ 46, 0, 677,
96, 0, 53,
- 97, 0, 1387
+ 97, 0, 1399
};
-static int parser_action_row1213[] = {
+static int parser_action_row1223[] = {
2,
-1, 1, 191,
- 24, 1, 922
+ 24, 1, 930
};
-static int parser_action_row1214[] = {
+static int parser_action_row1224[] = {
2,
-1, 1, 197,
- 24, 1, 928
+ 24, 1, 936
};
-static int parser_action_row1215[] = {
+static int parser_action_row1225[] = {
2,
-1, 1, 188,
- 24, 1, 919
+ 24, 1, 927
};
-static int parser_action_row1216[] = {
+static int parser_action_row1226[] = {
1,
-1, 1, 262
};
-static int parser_action_row1217[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1227[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1218[] = {
+static int parser_action_row1228[] = {
1,
-1, 1, 263
};
-static int parser_action_row1219[] = {
+static int parser_action_row1229[] = {
4,
- -1, 3, 1218,
+ -1, 3, 1228,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1220[] = {
+static int parser_action_row1230[] = {
1,
-1, 1, 258
};
-static int parser_action_row1221[] = {
+static int parser_action_row1231[] = {
2,
-1, 1, 199,
- 24, 1, 930
+ 24, 1, 938
};
-static int parser_action_row1222[] = {
+static int parser_action_row1232[] = {
2,
-1, 1, 190,
- 24, 1, 921
+ 24, 1, 929
};
-static int parser_action_row1223[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1233[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1224[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1234[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 345,
- 59, 0, 691,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 699,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 345,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1225[] = {
+static int parser_action_row1235[] = {
2,
- -1, 3, 1224,
- 15, 0, 1393
+ -1, 3, 1234,
+ 15, 0, 1405
};
-static int parser_action_row1226[] = {
+static int parser_action_row1236[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1227[] = {
+static int parser_action_row1237[] = {
1,
-1, 1, 336
};
-static int parser_action_row1228[] = {
+static int parser_action_row1238[] = {
2,
- -1, 3, 1227,
- 55, 0, 1395
+ -1, 3, 1237,
+ 55, 0, 1407
};
-static int parser_action_row1229[] = {
+static int parser_action_row1239[] = {
3,
- -1, 3, 1228,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1238,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1230[] = {
+static int parser_action_row1240[] = {
1,
- -1, 1, 1071
+ -1, 1, 1079
};
-static int parser_action_row1231[] = {
+static int parser_action_row1241[] = {
2,
- -1, 1, 797,
- 94, 0, 594
+ -1, 1, 803,
+ 94, 0, 602
};
-static int parser_action_row1232[] = {
+static int parser_action_row1242[] = {
2,
- -1, 3, 1231,
- 53, 0, 1398
+ -1, 3, 1241,
+ 53, 0, 1410
};
-static int parser_action_row1233[] = {
+static int parser_action_row1243[] = {
1,
- -1, 1, 798
+ -1, 1, 804
};
-static int parser_action_row1234[] = {
+static int parser_action_row1244[] = {
1,
-1, 1, 357
};
-static int parser_action_row1235[] = {
+static int parser_action_row1245[] = {
1,
-1, 1, 361
};
-static int parser_action_row1236[] = {
+static int parser_action_row1246[] = {
2,
-1, 1, 360,
- 52, 0, 277
+ 52, 0, 283
};
-static int parser_action_row1237[] = {
+static int parser_action_row1247[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1238[] = {
+static int parser_action_row1248[] = {
1,
- -1, 1, 410
+ -1, 1, 412
};
-static int parser_action_row1239[] = {
+static int parser_action_row1249[] = {
1,
- -1, 1, 412
+ -1, 1, 414
};
-static int parser_action_row1240[] = {
+static int parser_action_row1250[] = {
1,
- -1, 1, 413
+ -1, 1, 415
};
-static int parser_action_row1241[] = {
+static int parser_action_row1251[] = {
1,
- -1, 1, 414
+ -1, 1, 416
};
-static int parser_action_row1242[] = {
+static int parser_action_row1252[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1243[] = {
+static int parser_action_row1253[] = {
2,
- -1, 1, 425,
- 56, 0, 1402
+ -1, 1, 427,
+ 56, 0, 1414
};
-static int parser_action_row1244[] = {
+static int parser_action_row1254[] = {
1,
-1, 1, 276
};
-static int parser_action_row1245[] = {
+static int parser_action_row1255[] = {
2,
- -1, 3, 1244,
- 55, 0, 1405
+ -1, 3, 1254,
+ 55, 0, 1417
};
-static int parser_action_row1246[] = {
+static int parser_action_row1256[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1247[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1257[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1248[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1258[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1249[] = {
+static int parser_action_row1259[] = {
14,
-1, 1, 337,
- 52, 0, 277,
- 59, 0, 1407,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ 52, 0, 283,
+ 59, 0, 1419,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1250[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 446,
- 27, 0, 447,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1260[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 454,
+ 27, 0, 455,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1251[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1261[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1252[] = {
+static int parser_action_row1262[] = {
1,
- -1, 1, 594
+ -1, 1, 596
};
-static int parser_action_row1253[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1263[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1254[] = {
- 22,
- -1, 1, 458,
- 12, 0, 1102,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1264[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1255[] = {
+static int parser_action_row1265[] = {
3,
- -1, 3, 1254,
- 47, 0, 1413,
- 96, 0, 1414
+ -1, 3, 1264,
+ 47, 0, 1425,
+ 96, 0, 1426
};
-static int parser_action_row1256[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1266[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1257[] = {
+static int parser_action_row1267[] = {
1,
- -1, 1, 611
+ -1, 1, 613
};
-static int parser_action_row1258[] = {
+static int parser_action_row1268[] = {
1,
- -1, 1, 612
+ -1, 1, 614
};
-static int parser_action_row1259[] = {
+static int parser_action_row1269[] = {
1,
- -1, 1, 613
+ -1, 1, 615
};
-static int parser_action_row1260[] = {
+static int parser_action_row1270[] = {
1,
- -1, 1, 614
+ -1, 1, 616
};
-static int parser_action_row1261[] = {
+static int parser_action_row1271[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1262[] = {
+static int parser_action_row1272[] = {
3,
- -1, 3, 1261,
- 41, 0, 1272,
- 98, 0, 1418
+ -1, 3, 1271,
+ 41, 0, 1284,
+ 98, 0, 1430
};
-static int parser_action_row1263[] = {
+static int parser_action_row1273[] = {
2,
- -1, 3, 1262,
- 73, 0, 1419
+ -1, 3, 1272,
+ 73, 0, 1431
};
-static int parser_action_row1264[] = {
- 1,
- -1, 1, 564
-};
-static int parser_action_row1265[] = {
+static int parser_action_row1274[] = {
1,
- -1, 1, 563
+ -1, 1, 566
};
-static int parser_action_row1266[] = {
+static int parser_action_row1275[] = {
1,
-1, 1, 565
};
-static int parser_action_row1267[] = {
+static int parser_action_row1276[] = {
1,
- -1, 1, 576
+ -1, 1, 567
};
-static int parser_action_row1268[] = {
+static int parser_action_row1277[] = {
1,
- -1, 1, 615
+ -1, 1, 578
};
-static int parser_action_row1269[] = {
+static int parser_action_row1278[] = {
1,
- -1, 1, 616
+ -1, 1, 617
};
-static int parser_action_row1270[] = {
+static int parser_action_row1279[] = {
1,
- -1, 1, 617
+ -1, 1, 618
};
-static int parser_action_row1271[] = {
+static int parser_action_row1280[] = {
1,
-1, 1, 619
};
-static int parser_action_row1272[] = {
+static int parser_action_row1281[] = {
1,
- -1, 1, 618
+ -1, 1, 620
};
-static int parser_action_row1273[] = {
+static int parser_action_row1282[] = {
+ 1,
+ -1, 1, 621
+};
+static int parser_action_row1283[] = {
+ 1,
+ -1, 1, 623
+};
+static int parser_action_row1284[] = {
+ 1,
+ -1, 1, 622
+};
+static int parser_action_row1285[] = {
2,
- -1, 1, 592,
- 52, 0, 277
+ -1, 1, 594,
+ 52, 0, 283
};
-static int parser_action_row1274[] = {
+static int parser_action_row1286[] = {
1,
- -1, 1, 574
+ -1, 1, 576
};
-static int parser_action_row1275[] = {
+static int parser_action_row1287[] = {
2,
- -1, 1, 582,
- 52, 0, 277
+ -1, 1, 584,
+ 52, 0, 283
};
-static int parser_action_row1276[] = {
+static int parser_action_row1288[] = {
3,
- -1, 3, 1275,
- 54, 0, 1422,
- 55, 0, 1423
+ -1, 3, 1287,
+ 54, 0, 1434,
+ 55, 0, 1435
};
-static int parser_action_row1277[] = {
+static int parser_action_row1289[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1278[] = {
+static int parser_action_row1290[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 24, 0, 1425
+ 24, 0, 1437
};
-static int parser_action_row1279[] = {
+static int parser_action_row1291[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1280[] = {
+static int parser_action_row1292[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1281[] = {
+static int parser_action_row1293[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1282[] = {
+static int parser_action_row1294[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1283[] = {
+static int parser_action_row1295[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1284[] = {
+static int parser_action_row1296[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1285[] = {
+static int parser_action_row1297[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1286[] = {
+static int parser_action_row1298[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1287[] = {
+static int parser_action_row1299[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1288[] = {
+static int parser_action_row1300[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1289[] = {
+static int parser_action_row1301[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1290[] = {
+static int parser_action_row1302[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1291[] = {
+static int parser_action_row1303[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1292[] = {
+static int parser_action_row1304[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1293[] = {
+static int parser_action_row1305[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1294[] = {
+static int parser_action_row1306[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1295[] = {
+static int parser_action_row1307[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1296[] = {
+static int parser_action_row1308[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1297[] = {
+static int parser_action_row1309[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1298[] = {
+static int parser_action_row1310[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1299[] = {
+static int parser_action_row1311[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1300[] = {
+static int parser_action_row1312[] = {
3,
- -1, 1, 590,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 592,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1301[] = {
+static int parser_action_row1313[] = {
2,
- -1, 1, 456,
- 97, 0, 1449
+ -1, 1, 458,
+ 97, 0, 1461
};
-static int parser_action_row1302[] = {
+static int parser_action_row1314[] = {
2,
- -1, 1, 454,
- 58, 0, 215
+ -1, 1, 456,
+ 58, 0, 219
};
-static int parser_action_row1303[] = {
+static int parser_action_row1315[] = {
1,
- -1, 1, 1064
+ -1, 1, 1072
};
-static int parser_action_row1304[] = {
+static int parser_action_row1316[] = {
2,
-1, 1, 30,
13, 0, 32
};
-static int parser_action_row1305[] = {
+static int parser_action_row1317[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 9, 0, 1451,
+ 9, 0, 1463,
95, 0, 3
};
-static int parser_action_row1306[] = {
+static int parser_action_row1318[] = {
2,
-1, 1, 118,
- 71, 0, 1453
+ 71, 0, 1465
};
-static int parser_action_row1307[] = {
+static int parser_action_row1319[] = {
2,
- -1, 1, 404,
- 57, 0, 829
+ -1, 1, 406,
+ 57, 0, 837
};
-static int parser_action_row1308[] = {
+static int parser_action_row1320[] = {
1,
-1, 1, 117
};
-static int parser_action_row1309[] = {
+static int parser_action_row1321[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 57, 0, 829
+ 57, 0, 837
};
-static int parser_action_row1310[] = {
+static int parser_action_row1322[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1311[] = {
+static int parser_action_row1323[] = {
1,
- -1, 1, 1066
+ -1, 1, 1074
};
-static int parser_action_row1312[] = {
+static int parser_action_row1324[] = {
1,
-1, 1, 113
};
-static int parser_action_row1313[] = {
+static int parser_action_row1325[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 56, 0, 1309
+ 56, 0, 1321
};
-static int parser_action_row1314[] = {
+static int parser_action_row1326[] = {
1,
-1, 1, 128
};
-static int parser_action_row1315[] = {
+static int parser_action_row1327[] = {
2,
-1, 1, 122,
- 56, 0, 1460
+ 56, 0, 1472
};
-static int parser_action_row1316[] = {
+static int parser_action_row1328[] = {
1,
-1, 1, 126
};
-static int parser_action_row1317[] = {
+static int parser_action_row1329[] = {
1,
-1, 1, 127
};
-static int parser_action_row1318[] = {
+static int parser_action_row1330[] = {
2,
-1, 1, 131,
- 73, 0, 1463
+ 73, 0, 1475
};
-static int parser_action_row1319[] = {
+static int parser_action_row1331[] = {
1,
-1, 1, 129
};
-static int parser_action_row1320[] = {
+static int parser_action_row1332[] = {
9,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
4, 1, 80,
- 9, 0, 1464,
+ 9, 0, 1476,
15, 1, 80,
28, 1, 80,
95, 0, 3,
- 109, 1, 80
+ 111, 1, 80
};
-static int parser_action_row1321[] = {
+static int parser_action_row1333[] = {
1,
- -1, 1, 470
+ -1, 1, 472
};
-static int parser_action_row1322[] = {
+static int parser_action_row1334[] = {
1,
- -1, 1, 491
+ -1, 1, 493
};
-static int parser_action_row1323[] = {
+static int parser_action_row1335[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1324[] = {
+static int parser_action_row1336[] = {
1,
- -1, 1, 495
+ -1, 1, 497
};
-static int parser_action_row1325[] = {
+static int parser_action_row1337[] = {
3,
-1, 1, 155,
- 57, 0, 333,
- 94, 0, 204
+ 57, 0, 341,
+ 94, 0, 208
};
-static int parser_action_row1326[] = {
+static int parser_action_row1338[] = {
2,
- -1, 3, 1325,
- 55, 0, 1468
+ -1, 3, 1337,
+ 55, 0, 1480
};
-static int parser_action_row1327[] = {
+static int parser_action_row1339[] = {
2,
-1, 1, 37,
- 56, 0, 1469
+ 56, 0, 1481
};
-static int parser_action_row1328[] = {
+static int parser_action_row1340[] = {
1,
-1, 1, 27
};
-static int parser_action_row1329[] = {
+static int parser_action_row1341[] = {
7,
- -1, 3, 1328,
- 10, 0, 1472,
- 11, 0, 1473,
- 12, 0, 1474,
- 16, 0, 1475,
- 38, 0, 1476,
- 41, 0, 1477
+ -1, 3, 1340,
+ 10, 0, 1484,
+ 11, 0, 1485,
+ 12, 0, 1486,
+ 16, 0, 1487,
+ 38, 0, 1488,
+ 41, 0, 1489
};
-static int parser_action_row1330[] = {
- 26,
- -1, 1, 1003,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1342[] = {
+ 28,
+ -1, 1, 1011,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1331[] = {
+static int parser_action_row1343[] = {
2,
- -1, 1, 1008,
- 49, 0, 197
+ -1, 1, 1016,
+ 49, 0, 201
};
-static int parser_action_row1332[] = {
+static int parser_action_row1344[] = {
2,
- -1, 1, 1005,
- 49, 0, 197
+ -1, 1, 1013,
+ 49, 0, 201
};
-static int parser_action_row1333[] = {
+static int parser_action_row1345[] = {
1,
- -1, 1, 1007
+ -1, 1, 1015
};
-static int parser_action_row1334[] = {
+static int parser_action_row1346[] = {
2,
- -1, 3, 1333,
- 11, 0, 1481
+ -1, 3, 1345,
+ 11, 0, 1493
};
-static int parser_action_row1335[] = {
+static int parser_action_row1347[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1336[] = {
- 24,
- -1, 1, 498,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1348[] = {
+ 26,
+ -1, 1, 500,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1337[] = {
- 24,
- -1, 1, 499,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1349[] = {
+ 26,
+ -1, 1, 501,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1338[] = {
- 24,
- -1, 1, 507,
- 12, 0, 170,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1350[] = {
+ 26,
+ -1, 1, 509,
+ 12, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1339[] = {
+static int parser_action_row1351[] = {
15,
- -1, 1, 756,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1483,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 760,
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1495,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1340[] = {
+static int parser_action_row1352[] = {
1,
- -1, 1, 802
+ -1, 1, 808
};
-static int parser_action_row1341[] = {
+static int parser_action_row1353[] = {
1,
- -1, 1, 1001
+ -1, 1, 1009
};
-static int parser_action_row1342[] = {
+static int parser_action_row1354[] = {
1,
- -1, 1, 1010
+ -1, 1, 1018
};
-static int parser_action_row1343[] = {
+static int parser_action_row1355[] = {
1,
- -1, 1, 1012
+ -1, 1, 1020
};
-static int parser_action_row1344[] = {
+static int parser_action_row1356[] = {
1,
- -1, 1, 1011
+ -1, 1, 1019
};
-static int parser_action_row1345[] = {
+static int parser_action_row1357[] = {
1,
- -1, 1, 1013
+ -1, 1, 1021
};
-static int parser_action_row1346[] = {
+static int parser_action_row1358[] = {
1,
- -1, 1, 1014
+ -1, 1, 1022
};
-static int parser_action_row1347[] = {
+static int parser_action_row1359[] = {
1,
- -1, 1, 1015
+ -1, 1, 1023
};
-static int parser_action_row1348[] = {
+static int parser_action_row1360[] = {
1,
- -1, 1, 421
+ -1, 1, 423
};
-static int parser_action_row1349[] = {
+static int parser_action_row1361[] = {
3,
- -1, 3, 1348,
- 41, 0, 300,
- 98, 0, 1486
+ -1, 3, 1360,
+ 41, 0, 308,
+ 98, 0, 1498
};
-static int parser_action_row1350[] = {
+static int parser_action_row1362[] = {
22,
- -1, 1, 455,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1487
+ -1, 1, 457,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1499
};
-static int parser_action_row1351[] = {
+static int parser_action_row1363[] = {
1,
- -1, 1, 806
+ -1, 1, 812
};
-static int parser_action_row1352[] = {
+static int parser_action_row1364[] = {
1,
- -1, 1, 1002
+ -1, 1, 1010
};
-static int parser_action_row1353[] = {
+static int parser_action_row1365[] = {
1,
- -1, 1, 803
+ -1, 1, 809
};
-static int parser_action_row1354[] = {
+static int parser_action_row1366[] = {
3,
- -1, 1, 739,
- 54, 0, 244,
- 73, 0, 1488
+ -1, 1, 743,
+ 54, 0, 250,
+ 73, 0, 1500
};
-static int parser_action_row1355[] = {
+static int parser_action_row1367[] = {
1,
- -1, 1, 424
+ -1, 1, 426
};
-static int parser_action_row1356[] = {
+static int parser_action_row1368[] = {
2,
- -1, 1, 800,
- 56, 0, 1402
+ -1, 1, 806,
+ 56, 0, 1414
};
-static int parser_action_row1357[] = {
+static int parser_action_row1369[] = {
1,
- -1, 1, 804
+ -1, 1, 810
};
-static int parser_action_row1358[] = {
+static int parser_action_row1370[] = {
23,
- -1, 1, 457,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 1491
+ -1, 1, 459,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 1503
};
-static int parser_action_row1359[] = {
+static int parser_action_row1371[] = {
1,
-1, 1, 365
};
-static int parser_action_row1360[] = {
+static int parser_action_row1372[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1361[] = {
+static int parser_action_row1373[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1362[] = {
+static int parser_action_row1374[] = {
1,
-1, 1, 211
};
-static int parser_action_row1363[] = {
+static int parser_action_row1375[] = {
1,
-1, 1, 230
};
-static int parser_action_row1364[] = {
+static int parser_action_row1376[] = {
1,
-1, 1, 215
};
-static int parser_action_row1365[] = {
+static int parser_action_row1377[] = {
1,
-1, 1, 234
};
-static int parser_action_row1366[] = {
+static int parser_action_row1378[] = {
1,
-1, 1, 214
};
-static int parser_action_row1367[] = {
+static int parser_action_row1379[] = {
1,
-1, 1, 233
};
-static int parser_action_row1368[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1380[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1369[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1381[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1370[] = {
+static int parser_action_row1382[] = {
2,
- -1, 3, 1369,
- 24, 0, 1497
+ -1, 3, 1381,
+ 24, 0, 1509
};
-static int parser_action_row1371[] = {
+static int parser_action_row1383[] = {
1,
- -1, 1, 772
+ -1, 1, 776
};
-static int parser_action_row1372[] = {
+static int parser_action_row1384[] = {
1,
- -1, 1, 776
+ -1, 1, 780
};
-static int parser_action_row1373[] = {
+static int parser_action_row1385[] = {
2,
- -1, 1, 775,
- 52, 0, 277
+ -1, 1, 779,
+ 52, 0, 283
};
-static int parser_action_row1374[] = {
+static int parser_action_row1386[] = {
1,
- -1, 1, 446
+ -1, 1, 448
};
-static int parser_action_row1375[] = {
+static int parser_action_row1387[] = {
1,
- -1, 1, 780
+ -1, 1, 784
};
-static int parser_action_row1376[] = {
+static int parser_action_row1388[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1377[] = {
+static int parser_action_row1389[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1378[] = {
+static int parser_action_row1390[] = {
2,
- -1, 3, 1377,
- 23, 0, 1501
+ -1, 3, 1389,
+ 23, 0, 1513
};
-static int parser_action_row1379[] = {
+static int parser_action_row1391[] = {
2,
- -1, 3, 1378,
- 15, 0, 1502
+ -1, 3, 1390,
+ 15, 0, 1514
};
-static int parser_action_row1380[] = {
+static int parser_action_row1392[] = {
2,
- -1, 3, 1379,
- 28, 0, 1503
+ -1, 3, 1391,
+ 28, 0, 1515
};
-static int parser_action_row1381[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1393[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1381,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1393,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1382[] = {
+static int parser_action_row1394[] = {
2,
-1, 1, 158,
- 24, 1, 896
+ 24, 1, 904
};
-static int parser_action_row1383[] = {
- 31,
- -1, 1, 458,
- 9, 0, 1505,
+static int parser_action_row1395[] = {
+ 33,
+ -1, 1, 460,
+ 9, 0, 1517,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1384[] = {
+static int parser_action_row1396[] = {
1,
- -1, 1, 943
+ -1, 1, 951
};
-static int parser_action_row1385[] = {
+static int parser_action_row1397[] = {
2,
- -1, 3, 1384,
- 15, 0, 1507
+ -1, 3, 1396,
+ 15, 0, 1519
};
-static int parser_action_row1386[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1398[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1387[] = {
- 27,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1399[] = {
+ 29,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 351,
73, 1, 351,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1388[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1400[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 333,
- 58, 0, 215,
- 59, 0, 846,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 854,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 333,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1389[] = {
+static int parser_action_row1401[] = {
3,
- -1, 1, 455,
- 12, 0, 1511,
- 97, 0, 1512
+ -1, 1, 457,
+ 12, 0, 1523,
+ 97, 0, 1524
};
-static int parser_action_row1390[] = {
+static int parser_action_row1402[] = {
4,
- -1, 1, 457,
- 12, 0, 1513,
+ -1, 1, 459,
+ 12, 0, 1525,
96, 0, 53,
- 97, 0, 1514
+ 97, 0, 1526
};
-static int parser_action_row1391[] = {
+static int parser_action_row1403[] = {
1,
-1, 1, 260
};
-static int parser_action_row1392[] = {
+static int parser_action_row1404[] = {
2,
-1, 1, 198,
- 24, 1, 929
+ 24, 1, 937
};
-static int parser_action_row1393[] = {
+static int parser_action_row1405[] = {
2,
-1, 1, 189,
- 24, 1, 920
+ 24, 1, 928
};
-static int parser_action_row1394[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1406[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 157,
+ 9, 0, 161,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1395[] = {
+static int parser_action_row1407[] = {
2,
- -1, 3, 1394,
- 24, 0, 1518
+ -1, 3, 1406,
+ 24, 0, 1530
};
-static int parser_action_row1396[] = {
+static int parser_action_row1408[] = {
2,
- -1, 1, 797,
- 94, 0, 594
+ -1, 1, 803,
+ 94, 0, 602
};
-static int parser_action_row1397[] = {
+static int parser_action_row1409[] = {
1,
-1, 1, 152
};
-static int parser_action_row1398[] = {
+static int parser_action_row1410[] = {
1,
- -1, 1, 624
+ -1, 1, 628
};
-static int parser_action_row1399[] = {
+static int parser_action_row1411[] = {
1,
- -1, 1, 795
+ -1, 1, 801
};
-static int parser_action_row1400[] = {
+static int parser_action_row1412[] = {
1,
-1, 1, 359
};
-static int parser_action_row1401[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row1413[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1402[] = {
+static int parser_action_row1414[] = {
2,
- -1, 3, 1401,
- 53, 0, 1521
+ -1, 3, 1413,
+ 53, 0, 1533
};
-static int parser_action_row1403[] = {
+static int parser_action_row1415[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1404[] = {
+static int parser_action_row1416[] = {
1,
- -1, 1, 1082
+ -1, 1, 1090
};
-static int parser_action_row1405[] = {
+static int parser_action_row1417[] = {
2,
- -1, 1, 426,
- 56, 0, 1402
+ -1, 1, 428,
+ 56, 0, 1414
};
-static int parser_action_row1406[] = {
+static int parser_action_row1418[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1407[] = {
+static int parser_action_row1419[] = {
1,
-1, 1, 148
};
-static int parser_action_row1408[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1420[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1409[] = {
+static int parser_action_row1421[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1410[] = {
+static int parser_action_row1422[] = {
1,
- -1, 1, 392
+ -1, 1, 394
};
-static int parser_action_row1411[] = {
+static int parser_action_row1423[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1412[] = {
+static int parser_action_row1424[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1413[] = {
+static int parser_action_row1425[] = {
1,
- -1, 1, 534
+ -1, 1, 536
};
-static int parser_action_row1414[] = {
+static int parser_action_row1426[] = {
2,
- -1, 3, 1413,
- 96, 0, 1528
+ -1, 3, 1425,
+ 96, 0, 1540
};
-static int parser_action_row1415[] = {
+static int parser_action_row1427[] = {
2,
- -1, 1, 797,
- 94, 0, 594
+ -1, 1, 803,
+ 94, 0, 602
};
-static int parser_action_row1416[] = {
+static int parser_action_row1428[] = {
3,
- -1, 1, 569,
- 52, 0, 277,
- 73, 0, 1530
+ -1, 1, 571,
+ 52, 0, 283,
+ 73, 0, 1542
};
-static int parser_action_row1417[] = {
+static int parser_action_row1429[] = {
1,
- -1, 1, 566
+ -1, 1, 568
};
-static int parser_action_row1418[] = {
+static int parser_action_row1430[] = {
3,
- -1, 3, 1417,
- 47, 0, 1413,
- 96, 0, 1414
+ -1, 3, 1429,
+ 47, 0, 1425,
+ 96, 0, 1426
};
-static int parser_action_row1419[] = {
+static int parser_action_row1431[] = {
2,
- -1, 1, 571,
- 73, 1, 574
+ -1, 1, 573,
+ 73, 1, 576
};
-static int parser_action_row1420[] = {
+static int parser_action_row1432[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1421[] = {
+static int parser_action_row1433[] = {
1,
- -1, 1, 591
+ -1, 1, 593
};
-static int parser_action_row1422[] = {
+static int parser_action_row1434[] = {
1,
- -1, 1, 580
+ -1, 1, 582
};
-static int parser_action_row1423[] = {
+static int parser_action_row1435[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1424[] = {
+static int parser_action_row1436[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1425[] = {
- 22,
- -1, 1, 458,
- 12, 0, 1102,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1437[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1426[] = {
+static int parser_action_row1438[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1427[] = {
- 22,
- -1, 1, 458,
- 12, 0, 1102,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1439[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1428[] = {
- 22,
- -1, 1, 458,
- 12, 0, 1102,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1440[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1429[] = {
+static int parser_action_row1441[] = {
3,
- -1, 3, 1428,
- 47, 0, 1540,
- 96, 0, 1541
+ -1, 3, 1440,
+ 47, 0, 1552,
+ 96, 0, 1553
};
-static int parser_action_row1430[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1442[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1431[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1443[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1432[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1444[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1433[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1445[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1434[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1446[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1435[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1447[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1436[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1448[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1437[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1449[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1438[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1450[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1439[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1451[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1440[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1452[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1441[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1453[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1442[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1454[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1443[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1455[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1444[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1456[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1445[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1457[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1446[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1458[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1447[] = {
- 21,
- -1, 1, 458,
- 12, 0, 1102,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1459[] = {
+ 23,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1448[] = {
+static int parser_action_row1460[] = {
5,
- -1, 1, 458,
- 12, 0, 1561,
- 46, 0, 1562,
+ -1, 1, 460,
+ 12, 0, 1573,
+ 46, 0, 1574,
96, 0, 53,
- 97, 0, 1563
+ 97, 0, 1575
};
-static int parser_action_row1449[] = {
+static int parser_action_row1461[] = {
1,
- -1, 1, 588
+ -1, 1, 590
};
-static int parser_action_row1450[] = {
+static int parser_action_row1462[] = {
2,
- -1, 1, 586,
- 52, 0, 277
+ -1, 1, 588,
+ 52, 0, 283
};
-static int parser_action_row1451[] = {
+static int parser_action_row1463[] = {
5,
-1, 1, 81,
- 18, 0, 236,
- 19, 0, 237,
- 20, 0, 238,
- 21, 0, 239
+ 18, 0, 242,
+ 19, 0, 243,
+ 20, 0, 244,
+ 21, 0, 245
};
-static int parser_action_row1452[] = {
+static int parser_action_row1464[] = {
1,
-1, 1, 77
};
-static int parser_action_row1453[] = {
+static int parser_action_row1465[] = {
1,
- -1, 1, 1065
+ -1, 1, 1073
};
-static int parser_action_row1454[] = {
+static int parser_action_row1466[] = {
1,
-1, 1, 120
};
-static int parser_action_row1455[] = {
+static int parser_action_row1467[] = {
2,
-1, 1, 119,
- 71, 0, 1569
+ 71, 0, 1581
};
-static int parser_action_row1456[] = {
+static int parser_action_row1468[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1457[] = {
+static int parser_action_row1469[] = {
1,
-1, 1, 110
};
-static int parser_action_row1458[] = {
+static int parser_action_row1470[] = {
2,
- -1, 3, 1457,
- 97, 0, 1148
+ -1, 3, 1469,
+ 97, 0, 1158
};
-static int parser_action_row1459[] = {
+static int parser_action_row1471[] = {
1,
- -1, 1, 1067
+ -1, 1, 1075
};
-static int parser_action_row1460[] = {
+static int parser_action_row1472[] = {
1,
-1, 1, 114
};
-static int parser_action_row1461[] = {
+static int parser_action_row1473[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1462[] = {
+static int parser_action_row1474[] = {
1,
- -1, 1, 1068
+ -1, 1, 1076
};
-static int parser_action_row1463[] = {
+static int parser_action_row1475[] = {
2,
-1, 1, 123,
- 56, 0, 1460
+ 56, 0, 1472
};
-static int parser_action_row1464[] = {
+static int parser_action_row1476[] = {
24,
- -1, 3, 1463,
- 46, 0, 1574,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ -1, 3, 1475,
+ 46, 0, 1586,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row1465[] = {
+static int parser_action_row1477[] = {
1,
- -1, 1, 497
+ -1, 1, 499
};
-static int parser_action_row1466[] = {
+static int parser_action_row1478[] = {
1,
- -1, 1, 492
+ -1, 1, 494
};
-static int parser_action_row1467[] = {
+static int parser_action_row1479[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1468[] = {
+static int parser_action_row1480[] = {
2,
-1, 1, 155,
- 57, 0, 333
+ 57, 0, 341
};
-static int parser_action_row1469[] = {
+static int parser_action_row1481[] = {
6,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 28, 0, 84,
+ 28, 0, 86,
95, 0, 3,
- 109, 0, 85
+ 111, 0, 87
};
-static int parser_action_row1470[] = {
+static int parser_action_row1482[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1471[] = {
+static int parser_action_row1483[] = {
1,
- -1, 1, 1060
+ -1, 1, 1068
};
-static int parser_action_row1472[] = {
+static int parser_action_row1484[] = {
2,
-1, 1, 38,
- 56, 0, 1469
+ 56, 0, 1481
};
-static int parser_action_row1473[] = {
+static int parser_action_row1485[] = {
23,
- -1, 3, 1472,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ -1, 3, 1484,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row1474[] = {
+static int parser_action_row1486[] = {
2,
- -1, 3, 1473,
- 96, 0, 1583
+ -1, 3, 1485,
+ 96, 0, 1595
};
-static int parser_action_row1475[] = {
+static int parser_action_row1487[] = {
27,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 54, 0, 640,
- 57, 0, 829,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ 52, 0, 836,
+ 54, 0, 648,
+ 57, 0, 837,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row1476[] = {
+static int parser_action_row1488[] = {
2,
- -1, 3, 1475,
- 97, 0, 1586
+ -1, 3, 1487,
+ 97, 0, 1598
};
-static int parser_action_row1477[] = {
+static int parser_action_row1489[] = {
27,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 54, 0, 640,
- 57, 0, 829,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 53,
- 97, 0, 660
+ 52, 0, 836,
+ 54, 0, 648,
+ 57, 0, 837,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 53,
+ 97, 0, 668
};
-static int parser_action_row1478[] = {
+static int parser_action_row1490[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1479[] = {
+static int parser_action_row1491[] = {
1,
- -1, 1, 1004
+ -1, 1, 1012
};
-static int parser_action_row1480[] = {
+static int parser_action_row1492[] = {
1,
- -1, 1, 1009
+ -1, 1, 1017
};
-static int parser_action_row1481[] = {
+static int parser_action_row1493[] = {
1,
- -1, 1, 1006
+ -1, 1, 1014
};
-static int parser_action_row1482[] = {
+static int parser_action_row1494[] = {
3,
- -1, 3, 1481,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1493,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1483[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row1495[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1484[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1496[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1485[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1497[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1486[] = {
+static int parser_action_row1498[] = {
13,
- -1, 1, 755,
- 59, 0, 1594,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 759,
+ 59, 0, 1606,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1487[] = {
+static int parser_action_row1499[] = {
13,
- -1, 1, 746,
- 59, 0, 1596,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 750,
+ 59, 0, 1608,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1488[] = {
+static int parser_action_row1500[] = {
14,
- -1, 1, 758,
- 52, 0, 277,
- 59, 0, 1598,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 762,
+ 52, 0, 283,
+ 59, 0, 1610,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1489[] = {
+static int parser_action_row1501[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1490[] = {
+static int parser_action_row1502[] = {
13,
- -1, 1, 769,
- 59, 0, 1602,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 773,
+ 59, 0, 1614,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1491[] = {
+static int parser_action_row1503[] = {
2,
- -1, 1, 801,
- 56, 0, 1402
+ -1, 1, 807,
+ 56, 0, 1414
};
-static int parser_action_row1492[] = {
+static int parser_action_row1504[] = {
15,
- -1, 1, 762,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1604,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 766,
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1616,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1493[] = {
+static int parser_action_row1505[] = {
22,
- -1, 1, 456,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1607
+ -1, 1, 458,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1619
};
-static int parser_action_row1494[] = {
+static int parser_action_row1506[] = {
2,
- -1, 3, 1493,
- 45, 0, 1608
+ -1, 3, 1505,
+ 45, 0, 1620
};
-static int parser_action_row1495[] = {
+static int parser_action_row1507[] = {
2,
- -1, 3, 1494,
- 53, 0, 1609
+ -1, 3, 1506,
+ 53, 0, 1621
};
-static int parser_action_row1496[] = {
+static int parser_action_row1508[] = {
1,
-1, 1, 213
};
-static int parser_action_row1497[] = {
+static int parser_action_row1509[] = {
1,
-1, 1, 232
};
-static int parser_action_row1498[] = {
+static int parser_action_row1510[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1499[] = {
+static int parser_action_row1511[] = {
1,
- -1, 1, 774
+ -1, 1, 778
};
-static int parser_action_row1500[] = {
+static int parser_action_row1512[] = {
2,
- -1, 3, 1499,
- 45, 0, 1611
+ -1, 3, 1511,
+ 45, 0, 1623
};
-static int parser_action_row1501[] = {
+static int parser_action_row1513[] = {
2,
- -1, 3, 1500,
- 53, 0, 1612
+ -1, 3, 1512,
+ 53, 0, 1624
};
-static int parser_action_row1502[] = {
- 35,
- -1, 1, 458,
+static int parser_action_row1514[] = {
+ 37,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 886,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 894,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 24, 0, 890,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 24, 0, 898,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1503[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1515[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1035,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1043,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1504[] = {
+static int parser_action_row1516[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1505[] = {
+static int parser_action_row1517[] = {
1,
- -1, 1, 944
+ -1, 1, 952
};
-static int parser_action_row1506[] = {
+static int parser_action_row1518[] = {
2,
-1, 1, 157,
- 24, 1, 895
+ 24, 1, 903
};
-static int parser_action_row1507[] = {
+static int parser_action_row1519[] = {
2,
-1, 1, 156,
- 24, 1, 894
+ 24, 1, 902
};
-static int parser_action_row1508[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1520[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1035,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1043,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1509[] = {
+static int parser_action_row1521[] = {
2,
-1, 1, 200,
- 24, 1, 931
+ 24, 1, 939
};
-static int parser_action_row1510[] = {
+static int parser_action_row1522[] = {
2,
-1, 1, 192,
- 24, 1, 923
+ 24, 1, 931
};
-static int parser_action_row1511[] = {
+static int parser_action_row1523[] = {
2,
-1, 1, 183,
- 24, 1, 914
+ 24, 1, 922
};
-static int parser_action_row1512[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1524[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1513[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1525[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 335,
- 59, 0, 1007,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 1015,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 335,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1514[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1526[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1515[] = {
- 40,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1527[] = {
+ 42,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 339,
- 58, 0, 215,
- 59, 0, 1012,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 58, 0, 219,
+ 59, 0, 1020,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 339,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1516[] = {
+static int parser_action_row1528[] = {
3,
- -1, 1, 456,
- 12, 0, 1623,
- 97, 0, 1624
+ -1, 1, 458,
+ 12, 0, 1635,
+ 97, 0, 1636
};
-static int parser_action_row1517[] = {
+static int parser_action_row1529[] = {
1,
-1, 1, 272
};
-static int parser_action_row1518[] = {
+static int parser_action_row1530[] = {
2,
- -1, 3, 1517,
- 49, 0, 197
+ -1, 3, 1529,
+ 49, 0, 201
};
-static int parser_action_row1519[] = {
+static int parser_action_row1531[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1520[] = {
+static int parser_action_row1532[] = {
1,
- -1, 1, 625
+ -1, 1, 629
};
-static int parser_action_row1521[] = {
+static int parser_action_row1533[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1522[] = {
+static int parser_action_row1534[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1523[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row1535[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1524[] = {
+static int parser_action_row1536[] = {
1,
- -1, 1, 1083
+ -1, 1, 1091
};
-static int parser_action_row1525[] = {
+static int parser_action_row1537[] = {
1,
-1, 1, 149
};
-static int parser_action_row1526[] = {
+static int parser_action_row1538[] = {
2,
- -1, 1, 390,
- 24, 0, 1518
+ -1, 1, 392,
+ 24, 0, 1530
};
-static int parser_action_row1527[] = {
+static int parser_action_row1539[] = {
2,
- -1, 3, 1526,
- 15, 0, 1630
+ -1, 3, 1538,
+ 15, 0, 1642
};
-static int parser_action_row1528[] = {
+static int parser_action_row1540[] = {
2,
- -1, 3, 1527,
- 23, 0, 1631
+ -1, 3, 1539,
+ 23, 0, 1643
};
-static int parser_action_row1529[] = {
+static int parser_action_row1541[] = {
2,
- -1, 1, 797,
- 94, 0, 594
+ -1, 1, 803,
+ 94, 0, 602
};
-static int parser_action_row1530[] = {
+static int parser_action_row1542[] = {
1,
- -1, 1, 807
+ -1, 1, 813
};
-static int parser_action_row1531[] = {
+static int parser_action_row1543[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1532[] = {
+static int parser_action_row1544[] = {
1,
- -1, 1, 568
+ -1, 1, 570
};
-static int parser_action_row1533[] = {
+static int parser_action_row1545[] = {
2,
- -1, 3, 1532,
- 73, 0, 1530
+ -1, 3, 1544,
+ 73, 0, 1542
};
-static int parser_action_row1534[] = {
+static int parser_action_row1546[] = {
5,
- -1, 1, 458,
- 12, 0, 1561,
- 46, 0, 1562,
+ -1, 1, 460,
+ 12, 0, 1573,
+ 46, 0, 1574,
96, 0, 53,
- 97, 0, 1563
+ 97, 0, 1575
};
-static int parser_action_row1535[] = {
+static int parser_action_row1547[] = {
1,
- -1, 1, 381
+ -1, 1, 383
};
-static int parser_action_row1536[] = {
+static int parser_action_row1548[] = {
1,
- -1, 1, 380
+ -1, 1, 382
};
-static int parser_action_row1537[] = {
+static int parser_action_row1549[] = {
1,
- -1, 1, 530
+ -1, 1, 532
};
-static int parser_action_row1538[] = {
- 22,
- -1, 1, 458,
- 12, 0, 1102,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1550[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1539[] = {
+static int parser_action_row1551[] = {
1,
- -1, 1, 529
+ -1, 1, 531
};
-static int parser_action_row1540[] = {
+static int parser_action_row1552[] = {
1,
- -1, 1, 532
+ -1, 1, 534
};
-static int parser_action_row1541[] = {
+static int parser_action_row1553[] = {
2,
- -1, 3, 1540,
- 96, 0, 1636
+ -1, 3, 1552,
+ 96, 0, 1648
};
-static int parser_action_row1542[] = {
+static int parser_action_row1554[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1543[] = {
+static int parser_action_row1555[] = {
1,
- -1, 1, 543
+ -1, 1, 545
};
-static int parser_action_row1544[] = {
- 2,
- -1, 1, 545,
- 81, 0, 1288
-};
-static int parser_action_row1545[] = {
- 2,
- -1, 1, 536,
- 80, 0, 1280
-};
-static int parser_action_row1546[] = {
+static int parser_action_row1556[] = {
2,
- -1, 1, 537,
- 80, 0, 1280
+ -1, 1, 547,
+ 81, 0, 1300
};
-static int parser_action_row1547[] = {
+static int parser_action_row1557[] = {
2,
-1, 1, 538,
- 80, 0, 1280
+ 80, 0, 1292
};
-static int parser_action_row1548[] = {
+static int parser_action_row1558[] = {
2,
-1, 1, 539,
- 80, 0, 1280
+ 80, 0, 1292
};
-static int parser_action_row1549[] = {
+static int parser_action_row1559[] = {
2,
-1, 1, 540,
- 80, 0, 1280
+ 80, 0, 1292
};
-static int parser_action_row1550[] = {
+static int parser_action_row1560[] = {
2,
-1, 1, 541,
- 80, 0, 1280
+ 80, 0, 1292
};
-static int parser_action_row1551[] = {
+static int parser_action_row1561[] = {
2,
-1, 1, 542,
- 80, 0, 1280
+ 80, 0, 1292
};
-static int parser_action_row1552[] = {
+static int parser_action_row1562[] = {
2,
- -1, 1, 547,
- 82, 0, 1289
+ -1, 1, 543,
+ 80, 0, 1292
};
-static int parser_action_row1553[] = {
- 3,
+static int parser_action_row1563[] = {
+ 2,
+ -1, 1, 544,
+ 80, 0, 1292
+};
+static int parser_action_row1564[] = {
+ 2,
-1, 1, 549,
- 88, 0, 1290,
- 91, 0, 1291
+ 82, 0, 1301
};
-static int parser_action_row1554[] = {
+static int parser_action_row1565[] = {
3,
-1, 1, 551,
- 74, 0, 1292,
- 75, 0, 1293
+ 88, 0, 1302,
+ 91, 0, 1303
};
-static int parser_action_row1555[] = {
+static int parser_action_row1566[] = {
3,
- -1, 1, 552,
- 74, 0, 1292,
- 75, 0, 1293
+ -1, 1, 553,
+ 74, 0, 1304,
+ 75, 0, 1305
};
-static int parser_action_row1556[] = {
- 4,
+static int parser_action_row1567[] = {
+ 3,
-1, 1, 554,
- 76, 0, 1294,
- 78, 0, 1295,
- 79, 0, 1296
+ 74, 0, 1304,
+ 75, 0, 1305
};
-static int parser_action_row1557[] = {
+static int parser_action_row1568[] = {
4,
- -1, 1, 555,
- 76, 0, 1294,
- 78, 0, 1295,
- 79, 0, 1296
+ -1, 1, 556,
+ 76, 0, 1306,
+ 78, 0, 1307,
+ 79, 0, 1308
};
-static int parser_action_row1558[] = {
- 1,
- -1, 1, 557
+static int parser_action_row1569[] = {
+ 4,
+ -1, 1, 557,
+ 76, 0, 1306,
+ 78, 0, 1307,
+ 79, 0, 1308
};
-static int parser_action_row1559[] = {
+static int parser_action_row1570[] = {
1,
- -1, 1, 558
+ -1, 1, 559
};
-static int parser_action_row1560[] = {
+static int parser_action_row1571[] = {
1,
- -1, 1, 559
+ -1, 1, 560
};
-static int parser_action_row1561[] = {
+static int parser_action_row1572[] = {
1,
-1, 1, 561
};
-static int parser_action_row1562[] = {
+static int parser_action_row1573[] = {
+ 1,
+ -1, 1, 563
+};
+static int parser_action_row1574[] = {
2,
- -1, 1, 595,
- 52, 0, 277
+ -1, 1, 597,
+ 52, 0, 283
};
-static int parser_action_row1563[] = {
+static int parser_action_row1575[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1564[] = {
+static int parser_action_row1576[] = {
3,
- -1, 1, 577,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 579,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1565[] = {
+static int parser_action_row1577[] = {
2,
- -1, 3, 1564,
- 98, 0, 1641
+ -1, 3, 1576,
+ 98, 0, 1653
};
-static int parser_action_row1566[] = {
+static int parser_action_row1578[] = {
2,
- -1, 1, 455,
- 97, 0, 1642
+ -1, 1, 457,
+ 97, 0, 1654
};
-static int parser_action_row1567[] = {
+static int parser_action_row1579[] = {
3,
- -1, 1, 457,
+ -1, 1, 459,
96, 0, 53,
- 97, 0, 1643
+ 97, 0, 1655
};
-static int parser_action_row1568[] = {
+static int parser_action_row1580[] = {
1,
- -1, 1, 584
+ -1, 1, 586
};
-static int parser_action_row1569[] = {
+static int parser_action_row1581[] = {
4,
- -1, 3, 1568,
- 6, 0, 792,
- 17, 0, 793,
- 97, 0, 794
+ -1, 3, 1580,
+ 6, 0, 800,
+ 17, 0, 801,
+ 97, 0, 802
};
-static int parser_action_row1570[] = {
+static int parser_action_row1582[] = {
1,
-1, 1, 121
};
-static int parser_action_row1571[] = {
+static int parser_action_row1583[] = {
1,
-1, 1, 109
};
-static int parser_action_row1572[] = {
+static int parser_action_row1584[] = {
1,
-1, 1, 116
};
-static int parser_action_row1573[] = {
+static int parser_action_row1585[] = {
25,
- -1, 3, 1572,
- 41, 0, 1313,
- 47, 0, 396,
- 54, 0, 640,
- 74, 0, 641,
- 75, 0, 642,
- 76, 0, 643,
- 77, 0, 644,
- 78, 0, 645,
- 79, 0, 646,
- 80, 0, 647,
- 81, 0, 648,
- 82, 0, 649,
- 83, 0, 650,
- 84, 0, 651,
- 85, 0, 652,
- 86, 0, 653,
- 87, 0, 654,
- 88, 0, 655,
- 89, 0, 656,
- 90, 0, 657,
- 91, 0, 658,
- 92, 0, 659,
- 96, 0, 424,
- 97, 0, 660
+ -1, 3, 1584,
+ 41, 0, 1325,
+ 47, 0, 404,
+ 54, 0, 648,
+ 74, 0, 649,
+ 75, 0, 650,
+ 76, 0, 651,
+ 77, 0, 652,
+ 78, 0, 653,
+ 79, 0, 654,
+ 80, 0, 655,
+ 81, 0, 656,
+ 82, 0, 657,
+ 83, 0, 658,
+ 84, 0, 659,
+ 85, 0, 660,
+ 86, 0, 661,
+ 87, 0, 662,
+ 88, 0, 663,
+ 89, 0, 664,
+ 90, 0, 665,
+ 91, 0, 666,
+ 92, 0, 667,
+ 96, 0, 432,
+ 97, 0, 668
};
-static int parser_action_row1574[] = {
+static int parser_action_row1586[] = {
1,
- -1, 1, 1069
+ -1, 1, 1077
};
-static int parser_action_row1575[] = {
+static int parser_action_row1587[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1576[] = {
+static int parser_action_row1588[] = {
1,
-1, 1, 130
};
-static int parser_action_row1577[] = {
+static int parser_action_row1589[] = {
1,
-1, 1, 41
};
-static int parser_action_row1578[] = {
+static int parser_action_row1590[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1579[] = {
+static int parser_action_row1591[] = {
2,
- -1, 3, 1578,
- 9, 0, 1649
+ -1, 3, 1590,
+ 9, 0, 1661
};
-static int parser_action_row1580[] = {
+static int parser_action_row1592[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1581[] = {
+static int parser_action_row1593[] = {
2,
- -1, 3, 1580,
- 96, 0, 1324
+ -1, 3, 1592,
+ 96, 0, 1336
};
-static int parser_action_row1582[] = {
+static int parser_action_row1594[] = {
1,
- -1, 1, 1061
+ -1, 1, 1069
};
-static int parser_action_row1583[] = {
+static int parser_action_row1595[] = {
5,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 57, 0, 829
+ 52, 0, 836,
+ 57, 0, 837
};
-static int parser_action_row1584[] = {
+static int parser_action_row1596[] = {
2,
- -1, 3, 1583,
- 57, 0, 829
+ -1, 3, 1595,
+ 57, 0, 837
};
-static int parser_action_row1585[] = {
+static int parser_action_row1597[] = {
3,
- -1, 3, 1584,
- 14, 0, 1654,
- 15, 0, 1655
+ -1, 3, 1596,
+ 14, 0, 1666,
+ 15, 0, 1667
};
-static int parser_action_row1586[] = {
+static int parser_action_row1598[] = {
5,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 57, 0, 829
+ 52, 0, 836,
+ 57, 0, 837
};
-static int parser_action_row1587[] = {
+static int parser_action_row1599[] = {
2,
-1, 1, 155,
- 57, 0, 333
+ 57, 0, 341
};
-static int parser_action_row1588[] = {
+static int parser_action_row1600[] = {
4,
-1, 1, 124,
- 4, 0, 977,
- 14, 0, 978,
- 15, 0, 1659
+ 4, 0, 985,
+ 14, 0, 986,
+ 15, 0, 1671
};
-static int parser_action_row1589[] = {
+static int parser_action_row1601[] = {
5,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 52, 0, 828,
- 57, 0, 829
+ 52, 0, 836,
+ 57, 0, 837
};
-static int parser_action_row1590[] = {
+static int parser_action_row1602[] = {
3,
- -1, 3, 1589,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1601,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1591[] = {
+static int parser_action_row1603[] = {
2,
- -1, 3, 1590,
- 57, 0, 1665
+ -1, 3, 1602,
+ 57, 0, 1677
};
-static int parser_action_row1592[] = {
+static int parser_action_row1604[] = {
2,
- -1, 3, 1591,
- 53, 0, 1666
+ -1, 3, 1603,
+ 53, 0, 1678
};
-static int parser_action_row1593[] = {
+static int parser_action_row1605[] = {
1,
- -1, 1, 671
+ -1, 1, 675
};
-static int parser_action_row1594[] = {
+static int parser_action_row1606[] = {
1,
- -1, 1, 690
+ -1, 1, 694
};
-static int parser_action_row1595[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1607[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1596[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1608[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1597[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1609[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1598[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1610[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1599[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1611[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1600[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1612[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1601[] = {
+static int parser_action_row1613[] = {
13,
- -1, 1, 757,
- 59, 0, 1673,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 761,
+ 59, 0, 1685,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1602[] = {
+static int parser_action_row1614[] = {
25,
- -1, 1, 458,
- 12, 0, 730,
- 46, 0, 731,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 1675
+ -1, 1, 460,
+ 12, 0, 738,
+ 46, 0, 739,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 1687
};
-static int parser_action_row1603[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1615[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1604[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1616[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1605[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1617[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1606[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1618[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1607[] = {
+static int parser_action_row1619[] = {
13,
- -1, 1, 761,
- 59, 0, 1684,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 765,
+ 59, 0, 1696,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1608[] = {
+static int parser_action_row1620[] = {
14,
- -1, 1, 760,
- 52, 0, 277,
- 59, 0, 1686,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 764,
+ 52, 0, 283,
+ 59, 0, 1698,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1609[] = {
+static int parser_action_row1621[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1610[] = {
+static int parser_action_row1622[] = {
1,
-1, 1, 363
};
-static int parser_action_row1611[] = {
- 22,
- -1, 1, 458,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1623[] = {
+ 24,
+ -1, 1, 460,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1612[] = {
+static int parser_action_row1624[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1613[] = {
+static int parser_action_row1625[] = {
1,
- -1, 1, 778
+ -1, 1, 782
};
-static int parser_action_row1614[] = {
+static int parser_action_row1626[] = {
2,
- -1, 3, 1613,
- 24, 0, 1692
+ -1, 3, 1625,
+ 24, 0, 1704
};
-static int parser_action_row1615[] = {
+static int parser_action_row1627[] = {
1,
- -1, 1, 938
+ -1, 1, 946
};
-static int parser_action_row1616[] = {
+static int parser_action_row1628[] = {
2,
- -1, 3, 1615,
- 49, 0, 197
+ -1, 3, 1627,
+ 49, 0, 201
};
-static int parser_action_row1617[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1629[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1618[] = {
+static int parser_action_row1630[] = {
1,
- -1, 1, 942
+ -1, 1, 950
};
-static int parser_action_row1619[] = {
+static int parser_action_row1631[] = {
2,
- -1, 3, 1618,
- 49, 0, 197
+ -1, 3, 1630,
+ 49, 0, 201
};
-static int parser_action_row1620[] = {
+static int parser_action_row1632[] = {
2,
-1, 1, 194,
- 24, 1, 925
+ 24, 1, 933
};
-static int parser_action_row1621[] = {
+static int parser_action_row1633[] = {
2,
-1, 1, 184,
- 24, 1, 915
+ 24, 1, 923
};
-static int parser_action_row1622[] = {
+static int parser_action_row1634[] = {
2,
-1, 1, 196,
- 24, 1, 927
+ 24, 1, 935
};
-static int parser_action_row1623[] = {
+static int parser_action_row1635[] = {
2,
-1, 1, 186,
- 24, 1, 917
+ 24, 1, 925
};
-static int parser_action_row1624[] = {
- 25,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 486,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+static int parser_action_row1636[] = {
+ 27,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 494,
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1625[] = {
- 39,
- -1, 1, 442,
- 12, 0, 116,
- 22, 0, 117,
- 31, 0, 118,
- 38, 0, 119,
- 40, 0, 120,
- 41, 1, 458,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 48, 0, 125,
- 52, 0, 126,
+static int parser_action_row1637[] = {
+ 41,
+ -1, 1, 444,
+ 12, 0, 118,
+ 22, 0, 119,
+ 31, 0, 120,
+ 38, 0, 121,
+ 40, 0, 122,
+ 41, 1, 460,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 48, 0, 127,
+ 52, 0, 128,
54, 1, 337,
- 59, 0, 1187,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227,
+ 59, 0, 1197,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231,
73, 1, 337,
- 74, 0, 127,
- 75, 0, 128,
- 83, 0, 129,
- 96, 0, 53,
- 97, 0, 130,
- 98, 1, 458,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 74, 0, 129,
+ 75, 0, 130,
+ 83, 0, 131,
+ 96, 0, 53,
+ 97, 0, 132,
+ 98, 1, 460,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1626[] = {
+static int parser_action_row1638[] = {
1,
-1, 1, 271
};
-static int parser_action_row1627[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1639[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1628[] = {
+static int parser_action_row1640[] = {
2,
- -1, 3, 1627,
- 53, 0, 1699
+ -1, 3, 1639,
+ 53, 0, 1711
};
-static int parser_action_row1629[] = {
+static int parser_action_row1641[] = {
1,
- -1, 1, 407
+ -1, 1, 409
};
-static int parser_action_row1630[] = {
+static int parser_action_row1642[] = {
1,
- -1, 1, 427
+ -1, 1, 429
};
-static int parser_action_row1631[] = {
- 25,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 446,
- 27, 0, 447,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1643[] = {
+ 27,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 454,
+ 27, 0, 455,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1632[] = {
+static int parser_action_row1644[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1633[] = {
+static int parser_action_row1645[] = {
1,
- -1, 1, 808
+ -1, 1, 814
};
-static int parser_action_row1634[] = {
+static int parser_action_row1646[] = {
3,
- -1, 3, 1633,
+ -1, 3, 1645,
96, 0, 53,
- 97, 0, 1702
+ 97, 0, 1714
};
-static int parser_action_row1635[] = {
+static int parser_action_row1647[] = {
2,
- -1, 3, 1634,
- 98, 0, 1705
+ -1, 3, 1646,
+ 98, 0, 1717
};
-static int parser_action_row1636[] = {
+static int parser_action_row1648[] = {
1,
- -1, 1, 531
+ -1, 1, 533
};
-static int parser_action_row1637[] = {
+static int parser_action_row1649[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1638[] = {
+static int parser_action_row1650[] = {
1,
- -1, 1, 524
+ -1, 1, 526
};
-static int parser_action_row1639[] = {
+static int parser_action_row1651[] = {
1,
- -1, 1, 593
+ -1, 1, 595
};
-static int parser_action_row1640[] = {
+static int parser_action_row1652[] = {
3,
- -1, 3, 1639,
- 31, 0, 1707,
- 52, 0, 1708
+ -1, 3, 1651,
+ 31, 0, 1719,
+ 52, 0, 1720
};
-static int parser_action_row1641[] = {
+static int parser_action_row1653[] = {
1,
- -1, 1, 575
+ -1, 1, 577
};
-static int parser_action_row1642[] = {
+static int parser_action_row1654[] = {
1,
- -1, 1, 573
+ -1, 1, 575
};
-static int parser_action_row1643[] = {
+static int parser_action_row1655[] = {
2,
- -1, 1, 581,
- 52, 0, 277
+ -1, 1, 583,
+ 52, 0, 283
};
-static int parser_action_row1644[] = {
+static int parser_action_row1656[] = {
3,
- -1, 1, 589,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 591,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1645[] = {
+static int parser_action_row1657[] = {
2,
- -1, 1, 456,
- 97, 0, 1711
-};
-static int parser_action_row1646[] = {
- 57,
-1, 1, 458,
- 0, 0, 88,
- 1, 0, 89,
- 12, 0, 116,
+ 97, 0, 1723
+};
+static int parser_action_row1658[] = {
+ 59,
+ -1, 1, 460,
+ 0, 0, 90,
+ 1, 0, 91,
+ 12, 0, 118,
15, 0, 33,
16, 0, 34,
- 22, 0, 117,
+ 22, 0, 119,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 118,
- 33, 0, 1329,
- 34, 0, 1330,
- 35, 0, 1331,
- 36, 0, 1332,
+ 31, 0, 120,
+ 33, 0, 1341,
+ 34, 0, 1342,
+ 35, 0, 1343,
+ 36, 0, 1344,
37, 0, 43,
- 38, 0, 119,
- 40, 0, 120,
- 42, 0, 121,
- 43, 0, 122,
- 44, 0, 123,
- 45, 0, 124,
- 47, 0, 396,
- 48, 0, 125,
+ 38, 0, 121,
+ 40, 0, 122,
+ 42, 0, 123,
+ 43, 0, 124,
+ 44, 0, 125,
+ 45, 0, 126,
+ 47, 0, 404,
+ 48, 0, 127,
50, 0, 49,
- 51, 0, 1333,
- 52, 0, 1712,
- 54, 0, 619,
- 74, 0, 1335,
- 75, 0, 1336,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 1337,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 95, 0, 90,
- 96, 0, 424,
- 97, 0, 1338,
- 99, 0, 131,
- 100, 0, 132,
- 101, 0, 133,
- 102, 0, 134,
- 103, 0, 59,
- 106, 0, 135
+ 51, 0, 1345,
+ 52, 0, 1724,
+ 54, 0, 627,
+ 74, 0, 1347,
+ 75, 0, 1348,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 1349,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 95, 0, 92,
+ 96, 0, 432,
+ 97, 0, 1350,
+ 99, 0, 133,
+ 100, 0, 134,
+ 101, 0, 135,
+ 102, 0, 136,
+ 103, 0, 137,
+ 104, 0, 138,
+ 105, 0, 61,
+ 108, 0, 139
};
-static int parser_action_row1647[] = {
+static int parser_action_row1659[] = {
1,
-1, 1, 125
};
-static int parser_action_row1648[] = {
+static int parser_action_row1660[] = {
5,
- -1, 3, 1647,
- 31, 0, 1716,
- 47, 0, 1717,
- 52, 0, 1718,
- 96, 0, 397
+ -1, 3, 1659,
+ 31, 0, 1728,
+ 47, 0, 1729,
+ 52, 0, 1730,
+ 96, 0, 405
};
-static int parser_action_row1649[] = {
+static int parser_action_row1661[] = {
1,
-1, 1, 42
};
-static int parser_action_row1650[] = {
+static int parser_action_row1662[] = {
1,
-1, 1, 28
};
-static int parser_action_row1651[] = {
+static int parser_action_row1663[] = {
2,
- -1, 3, 1650,
- 9, 0, 1720
+ -1, 3, 1662,
+ 9, 0, 1732
};
-static int parser_action_row1652[] = {
+static int parser_action_row1664[] = {
1,
-1, 1, 40
};
-static int parser_action_row1653[] = {
+static int parser_action_row1665[] = {
4,
-1, 1, 124,
- 4, 0, 977,
- 14, 0, 978,
- 15, 0, 1721
+ 4, 0, 985,
+ 14, 0, 986,
+ 15, 0, 1733
};
-static int parser_action_row1654[] = {
+static int parser_action_row1666[] = {
2,
-1, 1, 78,
- 14, 0, 969
+ 14, 0, 977
};
-static int parser_action_row1655[] = {
+static int parser_action_row1667[] = {
5,
-1, 1, 30,
- 0, 0, 88,
- 1, 0, 89,
+ 0, 0, 90,
+ 1, 0, 91,
13, 0, 32,
- 95, 0, 90
+ 95, 0, 92
};
-static int parser_action_row1656[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1668[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1657[] = {
+static int parser_action_row1669[] = {
2,
- -1, 3, 1656,
- 15, 0, 1729
+ -1, 3, 1668,
+ 15, 0, 1741
};
-static int parser_action_row1658[] = {
+static int parser_action_row1670[] = {
3,
- -1, 3, 1657,
- 14, 0, 1654,
- 15, 0, 1730
+ -1, 3, 1669,
+ 14, 0, 1666,
+ 15, 0, 1742
};
-static int parser_action_row1659[] = {
+static int parser_action_row1671[] = {
4,
-1, 1, 78,
- 14, 0, 1732,
- 15, 0, 1733,
- 59, 0, 1734
+ 14, 0, 1744,
+ 15, 0, 1745,
+ 59, 0, 1746
};
-static int parser_action_row1660[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1672[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1661[] = {
+static int parser_action_row1673[] = {
3,
-1, 1, 124,
- 4, 0, 977,
- 15, 0, 1738
+ 4, 0, 985,
+ 15, 0, 1750
};
-static int parser_action_row1662[] = {
+static int parser_action_row1674[] = {
3,
- -1, 3, 1661,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1673,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1663[] = {
+static int parser_action_row1675[] = {
1,
-1, 1, 51
};
-static int parser_action_row1664[] = {
+static int parser_action_row1676[] = {
4,
-1, 1, 124,
- 4, 0, 977,
- 14, 0, 978,
- 15, 0, 1741
+ 4, 0, 985,
+ 14, 0, 986,
+ 15, 0, 1753
};
-static int parser_action_row1665[] = {
+static int parser_action_row1677[] = {
2,
-1, 1, 78,
- 14, 0, 969
+ 14, 0, 977
};
-static int parser_action_row1666[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1678[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1667[] = {
+static int parser_action_row1679[] = {
2,
- -1, 1, 422,
- 94, 0, 204
+ -1, 1, 424,
+ 94, 0, 208
};
-static int parser_action_row1668[] = {
+static int parser_action_row1680[] = {
1,
- -1, 1, 670
+ -1, 1, 674
};
-static int parser_action_row1669[] = {
+static int parser_action_row1681[] = {
1,
- -1, 1, 689
+ -1, 1, 693
};
-static int parser_action_row1670[] = {
+static int parser_action_row1682[] = {
1,
- -1, 1, 661
+ -1, 1, 665
};
-static int parser_action_row1671[] = {
+static int parser_action_row1683[] = {
1,
- -1, 1, 680
+ -1, 1, 684
};
-static int parser_action_row1672[] = {
+static int parser_action_row1684[] = {
1,
- -1, 1, 673
+ -1, 1, 677
};
-static int parser_action_row1673[] = {
+static int parser_action_row1685[] = {
1,
- -1, 1, 692
+ -1, 1, 696
};
-static int parser_action_row1674[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1686[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1675[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1687[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1676[] = {
+static int parser_action_row1688[] = {
15,
- -1, 1, 748,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1750,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 752,
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1762,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1677[] = {
+static int parser_action_row1689[] = {
2,
- -1, 3, 1676,
- 98, 0, 1753
+ -1, 3, 1688,
+ 98, 0, 1765
};
-static int parser_action_row1678[] = {
+static int parser_action_row1690[] = {
22,
- -1, 1, 455,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1754
+ -1, 1, 457,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1766
};
-static int parser_action_row1679[] = {
+static int parser_action_row1691[] = {
1,
- -1, 1, 805
+ -1, 1, 811
};
-static int parser_action_row1680[] = {
+static int parser_action_row1692[] = {
23,
- -1, 1, 457,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 96, 0, 53,
- 97, 0, 1755
+ -1, 1, 459,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 96, 0, 53,
+ 97, 0, 1767
};
-static int parser_action_row1681[] = {
+static int parser_action_row1693[] = {
1,
- -1, 1, 678
+ -1, 1, 682
};
-static int parser_action_row1682[] = {
+static int parser_action_row1694[] = {
1,
- -1, 1, 697
+ -1, 1, 701
};
-static int parser_action_row1683[] = {
+static int parser_action_row1695[] = {
1,
- -1, 1, 677
+ -1, 1, 681
};
-static int parser_action_row1684[] = {
+static int parser_action_row1696[] = {
1,
- -1, 1, 696
+ -1, 1, 700
};
-static int parser_action_row1685[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1697[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1686[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1698[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1687[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1699[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1688[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1700[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1689[] = {
+static int parser_action_row1701[] = {
13,
- -1, 1, 759,
- 59, 0, 1761,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 763,
+ 59, 0, 1773,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1690[] = {
+static int parser_action_row1702[] = {
2,
- -1, 3, 1689,
- 53, 0, 1763
+ -1, 3, 1701,
+ 53, 0, 1775
};
-static int parser_action_row1691[] = {
+static int parser_action_row1703[] = {
1,
- -1, 1, 699
+ -1, 1, 703
};
-static int parser_action_row1692[] = {
+static int parser_action_row1704[] = {
2,
- -1, 3, 1691,
- 53, 0, 1764
+ -1, 3, 1703,
+ 53, 0, 1776
};
-static int parser_action_row1693[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1705[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1381,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1393,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1694[] = {
+static int parser_action_row1706[] = {
2,
-1, 1, 269,
- 24, 1, 937
+ 24, 1, 945
};
-static int parser_action_row1695[] = {
+static int parser_action_row1707[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1696[] = {
+static int parser_action_row1708[] = {
2,
-1, 1, 273,
- 24, 1, 941
+ 24, 1, 949
};
-static int parser_action_row1697[] = {
+static int parser_action_row1709[] = {
2,
-1, 1, 195,
- 24, 1, 926
+ 24, 1, 934
};
-static int parser_action_row1698[] = {
+static int parser_action_row1710[] = {
2,
-1, 1, 185,
- 24, 1, 916
+ 24, 1, 924
};
-static int parser_action_row1699[] = {
+static int parser_action_row1711[] = {
1,
-1, 1, 284
};
-static int parser_action_row1700[] = {
+static int parser_action_row1712[] = {
2,
- -1, 1, 405,
- 94, 0, 204
+ -1, 1, 407,
+ 94, 0, 208
};
-static int parser_action_row1701[] = {
+static int parser_action_row1713[] = {
1,
- -1, 1, 391
+ -1, 1, 393
};
-static int parser_action_row1702[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1714[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1703[] = {
+static int parser_action_row1715[] = {
3,
- -1, 1, 598,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 600,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1704[] = {
+static int parser_action_row1716[] = {
2,
- -1, 3, 1703,
- 97, 0, 1770
+ -1, 3, 1715,
+ 97, 0, 1782
};
-static int parser_action_row1705[] = {
+static int parser_action_row1717[] = {
3,
- -1, 3, 1704,
+ -1, 3, 1716,
96, 0, 53,
- 97, 0, 1771
+ 97, 0, 1783
};
-static int parser_action_row1706[] = {
+static int parser_action_row1718[] = {
2,
- -1, 1, 570,
- 73, 1, 573
+ -1, 1, 572,
+ 73, 1, 575
};
-static int parser_action_row1707[] = {
+static int parser_action_row1719[] = {
1,
- -1, 1, 525
+ -1, 1, 527
};
-static int parser_action_row1708[] = {
+static int parser_action_row1720[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1709[] = {
+static int parser_action_row1721[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1710[] = {
+static int parser_action_row1722[] = {
1,
- -1, 1, 579
+ -1, 1, 581
};
-static int parser_action_row1711[] = {
+static int parser_action_row1723[] = {
1,
- -1, 1, 587
+ -1, 1, 589
};
-static int parser_action_row1712[] = {
+static int parser_action_row1724[] = {
2,
- -1, 1, 585,
- 52, 0, 277
+ -1, 1, 587,
+ 52, 0, 283
};
-static int parser_action_row1713[] = {
+static int parser_action_row1725[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1714[] = {
+static int parser_action_row1726[] = {
4,
- -1, 3, 1713,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 1725,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row1715[] = {
+static int parser_action_row1727[] = {
1,
- -1, 1, 415
+ -1, 1, 417
};
-static int parser_action_row1716[] = {
+static int parser_action_row1728[] = {
4,
- -1, 3, 1715,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 1727,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row1717[] = {
+static int parser_action_row1729[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1718[] = {
+static int parser_action_row1730[] = {
2,
-1, 1, 135,
- 96, 0, 603
+ 96, 0, 611
};
-static int parser_action_row1719[] = {
+static int parser_action_row1731[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1720[] = {
+static int parser_action_row1732[] = {
1,
-1, 1, 133
};
-static int parser_action_row1721[] = {
+static int parser_action_row1733[] = {
1,
-1, 1, 29
};
-static int parser_action_row1722[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1734[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1723[] = {
+static int parser_action_row1735[] = {
3,
-1, 1, 124,
- 4, 0, 977,
- 15, 0, 1782
+ 4, 0, 985,
+ 15, 0, 1794
};
-static int parser_action_row1724[] = {
+static int parser_action_row1736[] = {
3,
- -1, 3, 1723,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1735,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1725[] = {
+static int parser_action_row1737[] = {
1,
-1, 1, 50
};
-static int parser_action_row1726[] = {
+static int parser_action_row1738[] = {
1,
-1, 1, 69
};
-static int parser_action_row1727[] = {
+static int parser_action_row1739[] = {
1,
-1, 1, 79
};
-static int parser_action_row1728[] = {
+static int parser_action_row1740[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1729[] = {
+static int parser_action_row1741[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1730[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1742[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1731[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1743[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1732[] = {
+static int parser_action_row1744[] = {
2,
- -1, 3, 1731,
- 15, 0, 1789
+ -1, 3, 1743,
+ 15, 0, 1801
};
-static int parser_action_row1733[] = {
+static int parser_action_row1745[] = {
5,
-1, 1, 30,
- 0, 0, 88,
- 1, 0, 89,
+ 0, 0, 90,
+ 1, 0, 91,
13, 0, 32,
- 95, 0, 90
+ 95, 0, 92
};
-static int parser_action_row1734[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1746[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1735[] = {
+static int parser_action_row1747[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1736[] = {
+static int parser_action_row1748[] = {
1,
-1, 1, 59
};
-static int parser_action_row1737[] = {
+static int parser_action_row1749[] = {
2,
- -1, 3, 1736,
- 15, 0, 1794
+ -1, 3, 1748,
+ 15, 0, 1806
};
-static int parser_action_row1738[] = {
+static int parser_action_row1750[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1739[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1751[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1740[] = {
+static int parser_action_row1752[] = {
3,
- -1, 3, 1739,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1751,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1741[] = {
+static int parser_action_row1753[] = {
1,
-1, 1, 70
};
-static int parser_action_row1742[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1754[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1743[] = {
+static int parser_action_row1755[] = {
3,
-1, 1, 124,
- 4, 0, 977,
- 15, 0, 1799
+ 4, 0, 985,
+ 15, 0, 1811
};
-static int parser_action_row1744[] = {
+static int parser_action_row1756[] = {
3,
- -1, 3, 1743,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1755,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1745[] = {
+static int parser_action_row1757[] = {
1,
-1, 1, 52
};
-static int parser_action_row1746[] = {
+static int parser_action_row1758[] = {
1,
-1, 1, 43
};
-static int parser_action_row1747[] = {
+static int parser_action_row1759[] = {
1,
- -1, 1, 1016
+ -1, 1, 1024
};
-static int parser_action_row1748[] = {
+static int parser_action_row1760[] = {
1,
- -1, 1, 423
+ -1, 1, 425
};
-static int parser_action_row1749[] = {
+static int parser_action_row1761[] = {
1,
- -1, 1, 672
+ -1, 1, 676
};
-static int parser_action_row1750[] = {
+static int parser_action_row1762[] = {
1,
- -1, 1, 691
+ -1, 1, 695
};
-static int parser_action_row1751[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1763[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1752[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1764[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1753[] = {
+static int parser_action_row1765[] = {
13,
- -1, 1, 747,
- 59, 0, 1804,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 751,
+ 59, 0, 1816,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1754[] = {
+static int parser_action_row1766[] = {
13,
- -1, 1, 745,
- 59, 0, 1806,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 749,
+ 59, 0, 1818,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1755[] = {
+static int parser_action_row1767[] = {
14,
- -1, 1, 750,
- 52, 0, 277,
- 59, 0, 1808,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 754,
+ 52, 0, 283,
+ 59, 0, 1820,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1756[] = {
+static int parser_action_row1768[] = {
15,
- -1, 1, 754,
- 52, 0, 277,
- 58, 0, 215,
- 59, 0, 1811,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 758,
+ 52, 0, 283,
+ 58, 0, 219,
+ 59, 0, 1823,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1757[] = {
+static int parser_action_row1769[] = {
22,
- -1, 1, 456,
- 54, 0, 619,
- 74, 0, 620,
- 75, 0, 621,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 622,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 97, 0, 1814
+ -1, 1, 458,
+ 54, 0, 627,
+ 74, 0, 628,
+ 75, 0, 629,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 630,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 97, 0, 1826
};
-static int parser_action_row1758[] = {
+static int parser_action_row1770[] = {
1,
- -1, 1, 676
+ -1, 1, 680
};
-static int parser_action_row1759[] = {
+static int parser_action_row1771[] = {
1,
- -1, 1, 695
+ -1, 1, 699
};
-static int parser_action_row1760[] = {
+static int parser_action_row1772[] = {
1,
- -1, 1, 675
+ -1, 1, 679
};
-static int parser_action_row1761[] = {
+static int parser_action_row1773[] = {
1,
- -1, 1, 694
+ -1, 1, 698
};
-static int parser_action_row1762[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1774[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1763[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1775[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1764[] = {
+static int parser_action_row1776[] = {
1,
-1, 1, 364
};
-static int parser_action_row1765[] = {
+static int parser_action_row1777[] = {
1,
- -1, 1, 779
+ -1, 1, 783
};
-static int parser_action_row1766[] = {
+static int parser_action_row1778[] = {
1,
- -1, 1, 934
+ -1, 1, 942
};
-static int parser_action_row1767[] = {
+static int parser_action_row1779[] = {
2,
- -1, 3, 1766,
- 15, 0, 1817
+ -1, 3, 1778,
+ 15, 0, 1829
};
-static int parser_action_row1768[] = {
+static int parser_action_row1780[] = {
1,
- -1, 1, 411
+ -1, 1, 413
};
-static int parser_action_row1769[] = {
+static int parser_action_row1781[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1770[] = {
+static int parser_action_row1782[] = {
1,
- -1, 1, 597
+ -1, 1, 599
};
-static int parser_action_row1771[] = {
+static int parser_action_row1783[] = {
2,
- -1, 1, 600,
- 52, 0, 277
+ -1, 1, 602,
+ 52, 0, 283
};
-static int parser_action_row1772[] = {
+static int parser_action_row1784[] = {
3,
- -1, 1, 604,
- 52, 0, 277,
- 58, 0, 215
+ -1, 1, 606,
+ 52, 0, 283,
+ 58, 0, 219
};
-static int parser_action_row1773[] = {
+static int parser_action_row1785[] = {
2,
- -1, 3, 1772,
- 97, 0, 1821
+ -1, 3, 1784,
+ 97, 0, 1833
};
-static int parser_action_row1774[] = {
+static int parser_action_row1786[] = {
2,
- -1, 3, 1773,
- 45, 0, 1822
+ -1, 3, 1785,
+ 45, 0, 1834
};
-static int parser_action_row1775[] = {
+static int parser_action_row1787[] = {
4,
- -1, 3, 1774,
- 31, 0, 1823,
- 47, 0, 396,
- 96, 0, 397
+ -1, 3, 1786,
+ 31, 0, 1835,
+ 47, 0, 404,
+ 96, 0, 405
};
-static int parser_action_row1776[] = {
+static int parser_action_row1788[] = {
1,
- -1, 1, 583
+ -1, 1, 585
};
-static int parser_action_row1777[] = {
- 54,
- -1, 1, 458,
- 12, 0, 170,
+static int parser_action_row1789[] = {
+ 56,
+ -1, 1, 460,
+ 12, 0, 174,
15, 0, 33,
16, 0, 34,
- 22, 0, 171,
+ 22, 0, 175,
25, 0, 36,
26, 0, 37,
27, 0, 38,
- 31, 0, 172,
- 33, 0, 399,
- 34, 0, 400,
- 35, 0, 401,
- 36, 0, 402,
+ 31, 0, 176,
+ 33, 0, 407,
+ 34, 0, 408,
+ 35, 0, 409,
+ 36, 0, 410,
37, 0, 43,
- 38, 0, 173,
- 40, 0, 174,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 47, 0, 396,
- 48, 0, 175,
+ 47, 0, 404,
+ 48, 0, 179,
50, 0, 49,
- 51, 0, 403,
+ 51, 0, 411,
52, 0, 51,
- 54, 0, 404,
- 74, 0, 405,
- 75, 0, 406,
- 76, 0, 407,
- 77, 0, 408,
- 78, 0, 409,
- 79, 0, 410,
- 80, 0, 411,
- 81, 0, 412,
- 82, 0, 413,
- 83, 0, 414,
- 84, 0, 415,
- 85, 0, 416,
- 86, 0, 417,
- 87, 0, 418,
- 88, 0, 419,
- 89, 0, 420,
- 90, 0, 421,
- 91, 0, 422,
- 92, 0, 423,
- 94, 0, 204,
- 96, 0, 424,
- 97, 0, 425,
+ 54, 0, 412,
+ 74, 0, 413,
+ 75, 0, 414,
+ 76, 0, 415,
+ 77, 0, 416,
+ 78, 0, 417,
+ 79, 0, 418,
+ 80, 0, 419,
+ 81, 0, 420,
+ 82, 0, 421,
+ 83, 0, 422,
+ 84, 0, 423,
+ 85, 0, 424,
+ 86, 0, 425,
+ 87, 0, 426,
+ 88, 0, 427,
+ 89, 0, 428,
+ 90, 0, 429,
+ 91, 0, 430,
+ 92, 0, 431,
+ 94, 0, 208,
+ 96, 0, 432,
+ 97, 0, 433,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1778[] = {
+static int parser_action_row1790[] = {
1,
- -1, 1, 416
+ -1, 1, 418
};
-static int parser_action_row1779[] = {
+static int parser_action_row1791[] = {
1,
- -1, 1, 419
+ -1, 1, 421
};
-static int parser_action_row1780[] = {
+static int parser_action_row1792[] = {
2,
- -1, 3, 1779,
- 47, 0, 1826
+ -1, 3, 1791,
+ 47, 0, 1838
};
-static int parser_action_row1781[] = {
+static int parser_action_row1793[] = {
4,
- -1, 3, 1780,
- 31, 0, 1827,
- 47, 0, 1828,
- 96, 0, 397
+ -1, 3, 1792,
+ 31, 0, 1839,
+ 47, 0, 1840,
+ 96, 0, 405
};
-static int parser_action_row1782[] = {
+static int parser_action_row1794[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1783[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1795[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1784[] = {
+static int parser_action_row1796[] = {
3,
- -1, 3, 1783,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1795,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1785[] = {
+static int parser_action_row1797[] = {
1,
-1, 1, 57
};
-static int parser_action_row1786[] = {
+static int parser_action_row1798[] = {
5,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
15, 1, 80,
95, 0, 3
};
-static int parser_action_row1787[] = {
+static int parser_action_row1799[] = {
1,
-1, 1, 65
};
-static int parser_action_row1788[] = {
+static int parser_action_row1800[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1789[] = {
+static int parser_action_row1801[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1790[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1802[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1791[] = {
+static int parser_action_row1803[] = {
2,
-1, 1, 76,
15, 1, 79
};
-static int parser_action_row1792[] = {
+static int parser_action_row1804[] = {
4,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
95, 0, 3
};
-static int parser_action_row1793[] = {
+static int parser_action_row1805[] = {
2,
-1, 1, 61,
- 9, 0, 1837
+ 9, 0, 1849
};
-static int parser_action_row1794[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1806[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1795[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1807[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1796[] = {
+static int parser_action_row1808[] = {
1,
-1, 1, 53
};
-static int parser_action_row1797[] = {
+static int parser_action_row1809[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1798[] = {
+static int parser_action_row1810[] = {
1,
-1, 1, 72
};
-static int parser_action_row1799[] = {
+static int parser_action_row1811[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1800[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1812[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 589,
+ 9, 0, 597,
12, 0, 31,
15, 0, 33,
16, 0, 34,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1801[] = {
+static int parser_action_row1813[] = {
3,
- -1, 3, 1800,
- 28, 0, 84,
- 109, 0, 85
+ -1, 3, 1812,
+ 28, 0, 86,
+ 111, 0, 87
};
-static int parser_action_row1802[] = {
+static int parser_action_row1814[] = {
1,
-1, 1, 71
};
-static int parser_action_row1803[] = {
+static int parser_action_row1815[] = {
1,
- -1, 1, 663
+ -1, 1, 667
};
-static int parser_action_row1804[] = {
+static int parser_action_row1816[] = {
1,
- -1, 1, 682
+ -1, 1, 686
};
-static int parser_action_row1805[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1817[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1806[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1818[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1807[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1819[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1808[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1820[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1809[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1821[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1810[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1822[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1811[] = {
+static int parser_action_row1823[] = {
13,
- -1, 1, 749,
- 59, 0, 1850,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
-};
-static int parser_action_row1812[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+ -1, 1, 753,
+ 59, 0, 1862,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
+};
+static int parser_action_row1824[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1813[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1825[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1814[] = {
+static int parser_action_row1826[] = {
13,
- -1, 1, 753,
- 59, 0, 1854,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 757,
+ 59, 0, 1866,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1815[] = {
+static int parser_action_row1827[] = {
14,
- -1, 1, 752,
- 52, 0, 277,
- 59, 0, 1856,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 756,
+ 52, 0, 283,
+ 59, 0, 1868,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1816[] = {
+static int parser_action_row1828[] = {
1,
- -1, 1, 674
+ -1, 1, 678
};
-static int parser_action_row1817[] = {
+static int parser_action_row1829[] = {
1,
- -1, 1, 693
+ -1, 1, 697
};
-static int parser_action_row1818[] = {
- 34,
- -1, 1, 458,
+static int parser_action_row1830[] = {
+ 36,
+ -1, 1, 460,
0, 0, 1,
1, 0, 2,
- 9, 0, 1035,
- 12, 0, 887,
- 15, 0, 888,
+ 9, 0, 1043,
+ 12, 0, 895,
+ 15, 0, 896,
16, 0, 34,
- 22, 0, 889,
- 25, 0, 891,
- 26, 0, 892,
- 27, 0, 893,
- 33, 0, 894,
- 34, 0, 895,
- 35, 0, 896,
- 36, 0, 897,
- 37, 0, 898,
+ 22, 0, 897,
+ 25, 0, 899,
+ 26, 0, 900,
+ 27, 0, 901,
+ 33, 0, 902,
+ 34, 0, 903,
+ 35, 0, 904,
+ 36, 0, 905,
+ 37, 0, 906,
38, 0, 44,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 50, 0, 899,
- 51, 0, 900,
+ 50, 0, 907,
+ 51, 0, 908,
52, 0, 51,
54, 0, 52,
95, 0, 3,
96, 0, 53,
- 97, 0, 901,
+ 97, 0, 909,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1819[] = {
+static int parser_action_row1831[] = {
2,
- -1, 3, 1818,
- 24, 0, 1861
+ -1, 3, 1830,
+ 24, 0, 1873
};
-static int parser_action_row1820[] = {
+static int parser_action_row1832[] = {
1,
- -1, 1, 599
+ -1, 1, 601
};
-static int parser_action_row1821[] = {
+static int parser_action_row1833[] = {
1,
- -1, 1, 603
+ -1, 1, 605
};
-static int parser_action_row1822[] = {
+static int parser_action_row1834[] = {
2,
- -1, 1, 602,
- 52, 0, 277
+ -1, 1, 604,
+ 52, 0, 283
};
-static int parser_action_row1823[] = {
+static int parser_action_row1835[] = {
1,
- -1, 1, 607
+ -1, 1, 609
};
-static int parser_action_row1824[] = {
+static int parser_action_row1836[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1825[] = {
+static int parser_action_row1837[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1826[] = {
+static int parser_action_row1838[] = {
2,
- -1, 3, 1825,
- 53, 0, 1865
+ -1, 3, 1837,
+ 53, 0, 1877
};
-static int parser_action_row1827[] = {
+static int parser_action_row1839[] = {
1,
-1, 1, 137
};
-static int parser_action_row1828[] = {
+static int parser_action_row1840[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1829[] = {
+static int parser_action_row1841[] = {
4,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2,
- 96, 0, 603
+ 96, 0, 611
};
-static int parser_action_row1830[] = {
+static int parser_action_row1842[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1831[] = {
+static int parser_action_row1843[] = {
1,
-1, 1, 48
};
-static int parser_action_row1832[] = {
+static int parser_action_row1844[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1833[] = {
+static int parser_action_row1845[] = {
1,
-1, 1, 58
};
-static int parser_action_row1834[] = {
+static int parser_action_row1846[] = {
1,
-1, 1, 67
};
-static int parser_action_row1835[] = {
+static int parser_action_row1847[] = {
1,
-1, 1, 66
};
-static int parser_action_row1836[] = {
+static int parser_action_row1848[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1837[] = {
+static int parser_action_row1849[] = {
6,
- -1, 1, 485,
+ -1, 1, 487,
0, 0, 1,
1, 0, 2,
- 9, 0, 1451,
+ 9, 0, 1463,
15, 1, 80,
95, 0, 3
};
-static int parser_action_row1838[] = {
+static int parser_action_row1850[] = {
1,
-1, 1, 63
};
-static int parser_action_row1839[] = {
+static int parser_action_row1851[] = {
2,
-1, 1, 78,
- 14, 0, 969
+ 14, 0, 977
};
-static int parser_action_row1840[] = {
+static int parser_action_row1852[] = {
2,
-1, 1, 62,
- 9, 0, 1872
+ 9, 0, 1884
};
-static int parser_action_row1841[] = {
+static int parser_action_row1853[] = {
1,
-1, 1, 55
};
-static int parser_action_row1842[] = {
+static int parser_action_row1854[] = {
1,
-1, 1, 54
};
-static int parser_action_row1843[] = {
+static int parser_action_row1855[] = {
2,
- -1, 1, 469,
- 9, 0, 1320
+ -1, 1, 471,
+ 9, 0, 1332
};
-static int parser_action_row1844[] = {
+static int parser_action_row1856[] = {
1,
-1, 1, 73
};
-static int parser_action_row1845[] = {
+static int parser_action_row1857[] = {
1,
- -1, 1, 662
+ -1, 1, 666
};
-static int parser_action_row1846[] = {
+static int parser_action_row1858[] = {
1,
- -1, 1, 681
+ -1, 1, 685
};
-static int parser_action_row1847[] = {
+static int parser_action_row1859[] = {
1,
- -1, 1, 660
+ -1, 1, 664
};
-static int parser_action_row1848[] = {
+static int parser_action_row1860[] = {
1,
- -1, 1, 679
+ -1, 1, 683
};
-static int parser_action_row1849[] = {
+static int parser_action_row1861[] = {
1,
- -1, 1, 665
+ -1, 1, 669
};
-static int parser_action_row1850[] = {
+static int parser_action_row1862[] = {
1,
- -1, 1, 684
+ -1, 1, 688
};
-static int parser_action_row1851[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1863[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1852[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1864[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1853[] = {
+static int parser_action_row1865[] = {
1,
- -1, 1, 669
+ -1, 1, 673
};
-static int parser_action_row1854[] = {
+static int parser_action_row1866[] = {
1,
- -1, 1, 688
+ -1, 1, 692
};
-static int parser_action_row1855[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1867[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1856[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1868[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1857[] = {
- 26,
- -1, 1, 518,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
- 41, 1, 458,
+static int parser_action_row1869[] = {
+ 28,
+ -1, 1, 520,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
+ 41, 1, 460,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
- 98, 1, 458,
+ 97, 0, 183,
+ 98, 1, 460,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1858[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1870[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1859[] = {
+static int parser_action_row1871[] = {
13,
- -1, 1, 751,
- 59, 0, 1880,
- 60, 0, 217,
- 61, 0, 218,
- 62, 0, 219,
- 63, 0, 220,
- 64, 0, 221,
- 65, 0, 222,
- 66, 0, 223,
- 67, 0, 224,
- 68, 0, 225,
- 69, 0, 226,
- 70, 0, 227
+ -1, 1, 755,
+ 59, 0, 1892,
+ 60, 0, 221,
+ 61, 0, 222,
+ 62, 0, 223,
+ 63, 0, 224,
+ 64, 0, 225,
+ 65, 0, 226,
+ 66, 0, 227,
+ 67, 0, 228,
+ 68, 0, 229,
+ 69, 0, 230,
+ 70, 0, 231
};
-static int parser_action_row1860[] = {
+static int parser_action_row1872[] = {
1,
- -1, 1, 940
+ -1, 1, 948
};
-static int parser_action_row1861[] = {
+static int parser_action_row1873[] = {
2,
- -1, 3, 1860,
- 49, 0, 197
+ -1, 3, 1872,
+ 49, 0, 201
};
-static int parser_action_row1862[] = {
+static int parser_action_row1874[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1863[] = {
+static int parser_action_row1875[] = {
1,
- -1, 1, 601
+ -1, 1, 603
};
-static int parser_action_row1864[] = {
+static int parser_action_row1876[] = {
2,
- -1, 3, 1863,
- 45, 0, 1884
+ -1, 3, 1875,
+ 45, 0, 1896
};
-static int parser_action_row1865[] = {
+static int parser_action_row1877[] = {
2,
- -1, 3, 1864,
- 53, 0, 1885
+ -1, 3, 1876,
+ 53, 0, 1897
};
-static int parser_action_row1866[] = {
+static int parser_action_row1878[] = {
5,
- -1, 3, 1865,
- 0, 0, 88,
- 1, 0, 89,
- 94, 0, 204,
- 95, 0, 90
+ -1, 3, 1877,
+ 0, 0, 90,
+ 1, 0, 91,
+ 94, 0, 208,
+ 95, 0, 92
};
-static int parser_action_row1867[] = {
+static int parser_action_row1879[] = {
2,
- -1, 3, 1866,
- 47, 0, 1888
+ -1, 3, 1878,
+ 47, 0, 1900
};
-static int parser_action_row1868[] = {
+static int parser_action_row1880[] = {
2,
- -1, 3, 1867,
- 53, 0, 1889
+ -1, 3, 1879,
+ 53, 0, 1901
};
-static int parser_action_row1869[] = {
+static int parser_action_row1881[] = {
2,
- -1, 3, 1868,
- 53, 0, 1890
+ -1, 3, 1880,
+ 53, 0, 1902
};
-static int parser_action_row1870[] = {
+static int parser_action_row1882[] = {
1,
-1, 1, 49
};
-static int parser_action_row1871[] = {
+static int parser_action_row1883[] = {
1,
-1, 1, 68
};
-static int parser_action_row1872[] = {
+static int parser_action_row1884[] = {
1,
-1, 1, 60
};
-static int parser_action_row1873[] = {
+static int parser_action_row1885[] = {
1,
-1, 1, 64
};
-static int parser_action_row1874[] = {
+static int parser_action_row1886[] = {
1,
-1, 1, 56
};
-static int parser_action_row1875[] = {
+static int parser_action_row1887[] = {
1,
- -1, 1, 664
+ -1, 1, 668
};
-static int parser_action_row1876[] = {
+static int parser_action_row1888[] = {
1,
- -1, 1, 683
+ -1, 1, 687
};
-static int parser_action_row1877[] = {
+static int parser_action_row1889[] = {
1,
- -1, 1, 668
+ -1, 1, 672
};
-static int parser_action_row1878[] = {
+static int parser_action_row1890[] = {
1,
- -1, 1, 687
+ -1, 1, 691
};
-static int parser_action_row1879[] = {
+static int parser_action_row1891[] = {
1,
- -1, 1, 667
+ -1, 1, 671
};
-static int parser_action_row1880[] = {
+static int parser_action_row1892[] = {
1,
- -1, 1, 686
+ -1, 1, 690
};
-static int parser_action_row1881[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1893[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1882[] = {
- 24,
- -1, 1, 458,
- 12, 0, 170,
- 22, 0, 171,
- 31, 0, 172,
- 38, 0, 173,
- 40, 0, 174,
+static int parser_action_row1894[] = {
+ 26,
+ -1, 1, 460,
+ 12, 0, 174,
+ 22, 0, 175,
+ 31, 0, 176,
+ 38, 0, 177,
+ 40, 0, 178,
42, 0, 45,
43, 0, 46,
44, 0, 47,
45, 0, 48,
- 48, 0, 175,
+ 48, 0, 179,
52, 0, 51,
54, 0, 52,
- 74, 0, 176,
- 75, 0, 177,
- 83, 0, 178,
+ 74, 0, 180,
+ 75, 0, 181,
+ 83, 0, 182,
96, 0, 53,
- 97, 0, 179,
+ 97, 0, 183,
99, 0, 55,
100, 0, 56,
101, 0, 57,
102, 0, 58,
103, 0, 59,
- 106, 0, 60
+ 104, 0, 60,
+ 105, 0, 61,
+ 108, 0, 62
};
-static int parser_action_row1883[] = {
+static int parser_action_row1895[] = {
2,
-1, 1, 271,
- 24, 1, 939
+ 24, 1, 947
};
-static int parser_action_row1884[] = {
- 23,
- -1, 1, 458,
- 12, 0, 1102,
- 22, 0, 1103,
- 31, 0, 1104,
- 38, 0, 1105,
- 40, 0, 1106,
- 42, 0, 1107,
- 43, 0, 1108,
- 44, 0, 1109,
- 45, 0, 1110,
- 48, 0, 1111,
+static int parser_action_row1896[] = {
+ 25,
+ -1, 1, 460,
+ 12, 0, 1110,
+ 22, 0, 1111,
+ 31, 0, 1112,
+ 38, 0, 1113,
+ 40, 0, 1114,
+ 42, 0, 1115,
+ 43, 0, 1116,
+ 44, 0, 1117,
+ 45, 0, 1118,
+ 48, 0, 1119,
52, 0, 51,
- 74, 0, 1112,
- 75, 0, 1113,
- 83, 0, 1114,
- 96, 0, 53,
- 97, 0, 1115,
- 99, 0, 1116,
- 100, 0, 1117,
- 101, 0, 1118,
- 102, 0, 1119,
- 103, 0, 59,
- 106, 0, 1120
+ 74, 0, 1120,
+ 75, 0, 1121,
+ 83, 0, 1122,
+ 96, 0, 53,
+ 97, 0, 1123,
+ 99, 0, 1124,
+ 100, 0, 1125,
+ 101, 0, 1126,
+ 102, 0, 1127,
+ 103, 0, 1128,
+ 104, 0, 1129,
+ 105, 0, 61,
+ 108, 0, 1130
};
-static int parser_action_row1885[] = {
+static int parser_action_row1897[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1886[] = {
+static int parser_action_row1898[] = {
1,
- -1, 1, 605
+ -1, 1, 607
};
-static int parser_action_row1887[] = {
+static int parser_action_row1899[] = {
4,
- -1, 3, 1886,
- 0, 0, 88,
- 1, 0, 89,
- 95, 0, 90
+ -1, 3, 1898,
+ 0, 0, 90,
+ 1, 0, 91,
+ 95, 0, 92
};
-static int parser_action_row1888[] = {
+static int parser_action_row1900[] = {
1,
- -1, 1, 417
+ -1, 1, 419
};
-static int parser_action_row1889[] = {
+static int parser_action_row1901[] = {
3,
- -1, 1, 487,
+ -1, 1, 489,
0, 0, 1,
1, 0, 2
};
-static int parser_action_row1890[] = {
+static int parser_action_row1902[] = {
1,
-1, 1, 134
};
-static int parser_action_row1891[] = {
+static int parser_action_row1903[] = {
1,
-1, 1, 132
};
-static int parser_action_row1892[] = {
+static int parser_action_row1904[] = {
1,
- -1, 1, 666
+ -1, 1, 670
};
-static int parser_action_row1893[] = {
+static int parser_action_row1905[] = {
1,
- -1, 1, 685
+ -1, 1, 689
};
-static int parser_action_row1894[] = {
+static int parser_action_row1906[] = {
1,
- -1, 1, 527
+ -1, 1, 529
};
-static int parser_action_row1895[] = {
+static int parser_action_row1907[] = {
2,
- -1, 3, 1894,
- 53, 0, 1897
+ -1, 3, 1906,
+ 53, 0, 1909
};
-static int parser_action_row1896[] = {
+static int parser_action_row1908[] = {
1,
- -1, 1, 418
+ -1, 1, 420
};
-static int parser_action_row1897[] = {
+static int parser_action_row1909[] = {
2,
- -1, 3, 1896,
- 53, 0, 1898
+ -1, 3, 1908,
+ 53, 0, 1910
};
-static int parser_action_row1898[] = {
+static int parser_action_row1910[] = {
1,
- -1, 1, 606
+ -1, 1, 608
};
-static int parser_action_row1899[] = {
+static int parser_action_row1911[] = {
1,
-1, 1, 136
};
parser_action_row1896,
parser_action_row1897,
parser_action_row1898,
- parser_action_row1899
+ parser_action_row1899,
+ parser_action_row1900,
+ parser_action_row1901,
+ parser_action_row1902,
+ parser_action_row1903,
+ parser_action_row1904,
+ parser_action_row1905,
+ parser_action_row1906,
+ parser_action_row1907,
+ parser_action_row1908,
+ parser_action_row1909,
+ parser_action_row1910,
+ parser_action_row1911
};
static int parser_goto_row1[] = {
static int parser_goto_row3[] = {
3,
-1, 6,
- 18, 92,
- 28, 92
+ 18, 94,
+ 28, 94
};
static int parser_goto_row4[] = {
9,
-1, 7,
- 20, 100,
- 30, 100,
- 95, 100,
- 99, 100,
- 112, 100,
- 114, 100,
- 265, 100,
- 274, 100
+ 20, 102,
+ 30, 102,
+ 97, 102,
+ 101, 102,
+ 114, 102,
+ 116, 102,
+ 271, 102,
+ 280, 102
};
static int parser_goto_row5[] = {
16,
-1, 8,
5, 26,
- 18, 93,
- 19, 96,
- 20, 101,
- 28, 110,
- 29, 113,
- 30, 115,
- 94, 264,
- 95, 266,
- 99, 268,
- 111, 273,
- 112, 275,
- 114, 276,
- 265, 500,
- 274, 503
+ 18, 95,
+ 19, 98,
+ 20, 103,
+ 28, 112,
+ 29, 115,
+ 30, 117,
+ 96, 270,
+ 97, 272,
+ 101, 274,
+ 113, 279,
+ 114, 281,
+ 116, 282,
+ 271, 508,
+ 280, 511
};
static int parser_goto_row6[] = {
1,
};
static int parser_goto_row8[] = {
9,
- -1, 789,
- 13, 61,
- 27, 109,
- 98, 267,
- 204, 391,
- 594, 786,
- 993, 1165,
- 1169, 1165,
- 1303, 1450
+ -1, 797,
+ 13, 63,
+ 27, 111,
+ 100, 273,
+ 208, 399,
+ 602, 794,
+ 1001, 1175,
+ 1179, 1175,
+ 1315, 1462
};
static int parser_goto_row9[] = {
1,
- -1, 469
+ -1, 477
};
static int parser_goto_row10[] = {
1,
- -1, 1325
+ -1, 1337
};
static int parser_goto_row11[] = {
2,
- -1, 1470,
- 1471, 1581
+ -1, 1482,
+ 1483, 1593
};
static int parser_goto_row12[] = {
2,
- -1, 1326,
- 1580, 1651
+ -1, 1338,
+ 1592, 1663
};
static int parser_goto_row13[] = {
2,
- -1, 986,
- 994, 1167
+ -1, 994,
+ 1002, 1177
};
static int parser_goto_row14[] = {
4,
- -1, 987,
- 990, 1162,
- 1468, 1578,
- 1579, 1650
+ -1, 995,
+ 998, 1172,
+ 1480, 1590,
+ 1591, 1662
};
static int parser_goto_row15[] = {
2,
- -1, 988,
- 994, 1168
+ -1, 996,
+ 1002, 1178
};
static int parser_goto_row16[] = {
1,
- -1, 989
+ -1, 997
};
static int parser_goto_row17[] = {
6,
- -1, 970,
- 825, 973,
- 1653, 1725,
- 1658, 1735,
- 1664, 1745,
- 1838, 1871
+ -1, 978,
+ 833, 981,
+ 1665, 1737,
+ 1670, 1747,
+ 1676, 1757,
+ 1850, 1883
};
static int parser_goto_row18[] = {
7,
- -1, 980,
- 1584, 1656,
- 1587, 1660,
- 1652, 1722,
- 1657, 1731,
- 1658, 1736,
- 1663, 1742
+ -1, 988,
+ 1596, 1668,
+ 1599, 1672,
+ 1664, 1734,
+ 1669, 1743,
+ 1670, 1748,
+ 1675, 1754
};
static int parser_goto_row19[] = {
8,
- -1, 240,
- 109, 272,
- 267, 501,
- 391, 599,
- 786, 936,
- 789, 940,
- 1165, 1328,
- 1450, 1568
+ -1, 246,
+ 111, 278,
+ 273, 509,
+ 399, 607,
+ 794, 944,
+ 797, 948,
+ 1175, 1340,
+ 1462, 1580
};
static int parser_goto_row20[] = {
4,
- -1, 661,
- 663, 834,
- 664, 835,
- 836, 984
+ -1, 669,
+ 671, 842,
+ 672, 843,
+ 844, 992
};
static int parser_goto_row21[] = {
6,
- -1, 830,
- 1474, 1584,
- 1476, 1587,
- 1582, 1652,
- 1585, 1657,
- 1588, 1663
+ -1, 838,
+ 1486, 1596,
+ 1488, 1599,
+ 1594, 1664,
+ 1597, 1669,
+ 1600, 1675
};
static int parser_goto_row22[] = {
1,
- -1, 1149
+ -1, 1159
};
static int parser_goto_row23[] = {
2,
- -1, 1310,
- 1312, 1458
+ -1, 1322,
+ 1324, 1470
};
static int parser_goto_row24[] = {
2,
- -1, 1150,
- 1457, 1571
+ -1, 1160,
+ 1469, 1583
};
static int parser_goto_row25[] = {
8,
- -1, 981,
- 980, 1157,
- 1587, 1661,
- 1652, 1723,
- 1660, 1739,
- 1663, 1743,
- 1722, 1783,
- 1742, 1800
+ -1, 989,
+ 988, 1167,
+ 1599, 1673,
+ 1664, 1735,
+ 1672, 1751,
+ 1675, 1755,
+ 1734, 1795,
+ 1754, 1812
};
static int parser_goto_row26[] = {
2,
- -1, 1461,
- 1462, 1573
+ -1, 1473,
+ 1474, 1585
};
static int parser_goto_row27[] = {
2,
- -1, 1314,
- 1572, 1646
+ -1, 1326,
+ 1584, 1658
};
static int parser_goto_row28[] = {
1,
- -1, 1315
+ -1, 1327
};
static int parser_goto_row29[] = {
1,
- -1, 1316
+ -1, 1328
};
static int parser_goto_row30[] = {
1,
};
static int parser_goto_row31[] = {
1,
- -1, 86
+ -1, 88
};
static int parser_goto_row32[] = {
11,
- -1, 87,
- 839, 990,
- 981, 1158,
- 1157, 1323,
- 1468, 1579,
- 1661, 1740,
- 1723, 1784,
- 1739, 1797,
- 1743, 1801,
- 1783, 1832,
- 1800, 1843
+ -1, 89,
+ 847, 998,
+ 989, 1168,
+ 1167, 1335,
+ 1480, 1591,
+ 1673, 1752,
+ 1735, 1796,
+ 1751, 1809,
+ 1755, 1813,
+ 1795, 1844,
+ 1812, 1855
};
static int parser_goto_row33[] = {
1,
static int parser_goto_row34[] = {
5,
-1, 11,
- 19, 97,
- 29, 97,
- 94, 97,
- 111, 97
+ 19, 99,
+ 29, 99,
+ 96, 99,
+ 113, 99
};
static int parser_goto_row35[] = {
24,
- -1, 426,
- 211, 398,
- 523, 711,
- 547, 739,
- 565, 754,
- 610, 803,
- 784, 933,
- 801, 933,
- 932, 933,
- 951, 933,
- 976, 1151,
- 1052, 1210,
- 1152, 1317,
- 1166, 1339,
- 1173, 1360,
- 1198, 1376,
- 1228, 1396,
- 1481, 1590,
- 1572, 1317,
- 1589, 1664,
- 1645, 1339,
- 1647, 1719,
- 1774, 1824,
- 1780, 1829
+ -1, 434,
+ 215, 406,
+ 531, 719,
+ 555, 747,
+ 573, 762,
+ 618, 811,
+ 792, 941,
+ 809, 941,
+ 940, 941,
+ 959, 941,
+ 984, 1161,
+ 1060, 1220,
+ 1162, 1329,
+ 1176, 1351,
+ 1183, 1372,
+ 1208, 1388,
+ 1238, 1408,
+ 1493, 1602,
+ 1584, 1329,
+ 1601, 1676,
+ 1657, 1351,
+ 1659, 1731,
+ 1786, 1836,
+ 1792, 1841
};
static int parser_goto_row36[] = {
4,
- -1, 934,
- 801, 952,
- 932, 1074,
- 951, 1093
+ -1, 942,
+ 809, 960,
+ 940, 1082,
+ 959, 1101
};
static int parser_goto_row37[] = {
2,
- -1, 1076,
- 1077, 1229
+ -1, 1084,
+ 1085, 1239
};
static int parser_goto_row38[] = {
5,
- -1, 831,
- 1148, 1305,
- 1306, 1454,
- 1308, 1455,
- 1583, 1653
+ -1, 839,
+ 1158, 1317,
+ 1318, 1466,
+ 1320, 1467,
+ 1595, 1665
};
static int parser_goto_row39[] = {
8,
- -1, 334,
- 335, 549,
- 393, 600,
- 449, 631,
- 601, 797,
- 1324, 1466,
- 1467, 1577,
- 1586, 1658
+ -1, 342,
+ 343, 557,
+ 401, 608,
+ 457, 639,
+ 609, 805,
+ 1336, 1478,
+ 1479, 1589,
+ 1598, 1670
};
static int parser_goto_row40[] = {
32,
- -1, 158,
- 37, 167,
- 386, 590,
- 588, 779,
- 743, 919,
- 798, 949,
- 890, 1041,
- 892, 167,
- 979, 1155,
- 1058, 1215,
- 1062, 1219,
- 1156, 1322,
- 1208, 590,
- 1216, 1390,
- 1380, 779,
- 1393, 1516,
- 1502, 919,
- 1507, 949,
- 1655, 1728,
- 1659, 1737,
- 1692, 1219,
- 1721, 1781,
- 1729, 1787,
- 1730, 1788,
- 1733, 1792,
- 1738, 1796,
- 1741, 1798,
- 1782, 1831,
- 1789, 1835,
- 1794, 1839,
- 1799, 1842,
- 1817, 1516
+ -1, 162,
+ 37, 171,
+ 394, 598,
+ 596, 787,
+ 751, 927,
+ 806, 957,
+ 898, 1049,
+ 900, 171,
+ 987, 1165,
+ 1066, 1225,
+ 1070, 1229,
+ 1166, 1334,
+ 1218, 598,
+ 1226, 1402,
+ 1392, 787,
+ 1405, 1528,
+ 1514, 927,
+ 1519, 957,
+ 1667, 1740,
+ 1671, 1749,
+ 1704, 1229,
+ 1733, 1793,
+ 1741, 1799,
+ 1742, 1800,
+ 1745, 1804,
+ 1750, 1808,
+ 1753, 1810,
+ 1794, 1843,
+ 1801, 1847,
+ 1806, 1851,
+ 1811, 1854,
+ 1829, 1528
};
static int parser_goto_row41[] = {
1,
- -1, 62
+ -1, 64
};
static int parser_goto_row42[] = {
2,
- -1, 63,
- 909, 1059
+ -1, 65,
+ 917, 1067
};
static int parser_goto_row43[] = {
4,
- -1, 330,
- 591, 781,
- 1036, 1201,
- 1382, 1506
+ -1, 338,
+ 599, 789,
+ 1044, 1211,
+ 1394, 1518
};
static int parser_goto_row44[] = {
4,
- -1, 241,
- 243, 471,
- 546, 471,
- 1218, 471
+ -1, 247,
+ 249, 479,
+ 554, 479,
+ 1228, 479
};
static int parser_goto_row45[] = {
15,
- -1, 159,
- 13, 64,
- 27, 64,
- 98, 64,
- 160, 331,
- 242, 470,
- 472, 470,
- 545, 470,
- 591, 331,
- 738, 470,
- 742, 902,
- 909, 1060,
- 1036, 331,
- 1382, 331,
- 1501, 902
+ -1, 163,
+ 13, 66,
+ 27, 66,
+ 100, 66,
+ 164, 339,
+ 248, 478,
+ 480, 478,
+ 553, 478,
+ 599, 339,
+ 746, 478,
+ 750, 910,
+ 917, 1068,
+ 1044, 339,
+ 1394, 339,
+ 1513, 910
};
static int parser_goto_row46[] = {
18,
- -1, 198,
- 41, 199,
- 161, 332,
- 168, 339,
- 400, 608,
- 401, 609,
- 895, 1047,
- 896, 1048,
- 920, 1066,
- 950, 1092,
- 1039, 1202,
- 1044, 1205,
- 1330, 1479,
- 1331, 1480,
- 1517, 1625,
- 1615, 1693,
- 1618, 1695,
- 1860, 1882
+ -1, 202,
+ 41, 203,
+ 165, 340,
+ 172, 347,
+ 408, 616,
+ 409, 617,
+ 903, 1055,
+ 904, 1056,
+ 928, 1074,
+ 958, 1100,
+ 1047, 1212,
+ 1052, 1215,
+ 1342, 1491,
+ 1343, 1492,
+ 1529, 1637,
+ 1627, 1705,
+ 1630, 1707,
+ 1872, 1894
};
static int parser_goto_row47[] = {
20,
- -1, 65,
- 212, 427,
- 742, 903,
- 807, 427,
- 888, 903,
- 892, 903,
- 1089, 427,
- 1166, 1340,
- 1208, 903,
- 1380, 903,
- 1400, 427,
- 1482, 427,
- 1501, 903,
- 1502, 903,
- 1507, 903,
- 1522, 427,
- 1645, 1340,
- 1692, 903,
- 1776, 427,
- 1817, 903
+ -1, 67,
+ 216, 435,
+ 750, 911,
+ 815, 435,
+ 896, 911,
+ 900, 911,
+ 1097, 435,
+ 1176, 1352,
+ 1218, 911,
+ 1392, 911,
+ 1412, 435,
+ 1494, 435,
+ 1513, 911,
+ 1514, 911,
+ 1519, 911,
+ 1534, 435,
+ 1657, 1352,
+ 1704, 911,
+ 1788, 435,
+ 1829, 911
};
static int parser_goto_row48[] = {
18,
- -1, 66,
- 212, 428,
- 742, 904,
- 807, 428,
- 888, 904,
- 892, 904,
- 1089, 428,
- 1208, 904,
- 1380, 904,
- 1400, 428,
- 1482, 428,
- 1501, 904,
- 1502, 904,
- 1507, 904,
- 1522, 428,
- 1692, 904,
- 1776, 428,
- 1817, 904
+ -1, 68,
+ 216, 436,
+ 750, 912,
+ 815, 436,
+ 896, 912,
+ 900, 912,
+ 1097, 436,
+ 1218, 912,
+ 1392, 912,
+ 1412, 436,
+ 1494, 436,
+ 1513, 912,
+ 1514, 912,
+ 1519, 912,
+ 1534, 436,
+ 1704, 912,
+ 1788, 436,
+ 1829, 912
};
static int parser_goto_row49[] = {
52,
- -1, 228,
- 229, 456,
- 246, 476,
- 255, 485,
- 257, 489,
- 259, 494,
- 490, 685,
- 495, 689,
- 498, 692,
- 623, 489,
- 625, 494,
- 670, 847,
- 693, 866,
- 812, 692,
- 848, 1003,
- 850, 1005,
- 852, 1008,
- 854, 1013,
- 954, 847,
- 1009, 1181,
- 1014, 1185,
- 1017, 1188,
- 1057, 489,
- 1064, 494,
- 1097, 1008,
- 1098, 1013,
- 1189, 1368,
- 1223, 692,
- 1248, 1188,
- 1338, 1484,
- 1387, 847,
- 1485, 1595,
- 1486, 1597,
- 1487, 1599,
- 1489, 1603,
- 1491, 1605,
- 1512, 1008,
- 1514, 1013,
- 1600, 1674,
- 1606, 1685,
- 1607, 1687,
- 1624, 1188,
- 1675, 1751,
- 1688, 1762,
- 1752, 1805,
- 1753, 1807,
- 1754, 1809,
- 1755, 1812,
- 1810, 1851,
- 1813, 1855,
- 1814, 1857,
- 1858, 1881
+ -1, 232,
+ 233, 464,
+ 252, 484,
+ 261, 493,
+ 263, 497,
+ 265, 502,
+ 498, 693,
+ 503, 697,
+ 506, 700,
+ 631, 497,
+ 633, 502,
+ 678, 855,
+ 701, 874,
+ 820, 700,
+ 856, 1011,
+ 858, 1013,
+ 860, 1016,
+ 862, 1021,
+ 962, 855,
+ 1017, 1191,
+ 1022, 1195,
+ 1025, 1198,
+ 1065, 497,
+ 1072, 502,
+ 1105, 1016,
+ 1106, 1021,
+ 1199, 1380,
+ 1233, 700,
+ 1258, 1198,
+ 1350, 1496,
+ 1399, 855,
+ 1497, 1607,
+ 1498, 1609,
+ 1499, 1611,
+ 1501, 1615,
+ 1503, 1617,
+ 1524, 1016,
+ 1526, 1021,
+ 1612, 1686,
+ 1618, 1697,
+ 1619, 1699,
+ 1636, 1198,
+ 1687, 1763,
+ 1700, 1774,
+ 1764, 1817,
+ 1765, 1819,
+ 1766, 1821,
+ 1767, 1824,
+ 1822, 1863,
+ 1825, 1867,
+ 1826, 1869,
+ 1870, 1893
};
static int parser_goto_row50[] = {
10,
- -1, 67,
- 212, 429,
- 807, 429,
- 1089, 429,
- 1166, 1341,
- 1400, 429,
- 1482, 429,
- 1522, 429,
- 1645, 1341,
- 1776, 429
+ -1, 69,
+ 216, 437,
+ 815, 437,
+ 1097, 437,
+ 1176, 1353,
+ 1412, 437,
+ 1494, 437,
+ 1534, 437,
+ 1657, 1353,
+ 1788, 437
};
static int parser_goto_row51[] = {
1,
- -1, 68
+ -1, 70
};
static int parser_goto_row52[] = {
3,
- -1, 905,
- 909, 1061,
- 1059, 1217
+ -1, 913,
+ 917, 1069,
+ 1067, 1227
};
static int parser_goto_row53[] = {
10,
- -1, 69,
- 212, 430,
- 807, 430,
- 1089, 430,
- 1166, 1342,
- 1400, 430,
- 1482, 430,
- 1522, 430,
- 1645, 1342,
- 1776, 430
+ -1, 71,
+ 216, 438,
+ 815, 438,
+ 1097, 438,
+ 1176, 1354,
+ 1412, 438,
+ 1494, 438,
+ 1534, 438,
+ 1657, 1354,
+ 1788, 438
};
static int parser_goto_row54[] = {
10,
- -1, 70,
- 212, 431,
- 807, 431,
- 1089, 431,
- 1166, 1343,
- 1400, 431,
- 1482, 431,
- 1522, 431,
- 1645, 1343,
- 1776, 431
+ -1, 72,
+ 216, 439,
+ 815, 439,
+ 1097, 439,
+ 1176, 1355,
+ 1412, 439,
+ 1494, 439,
+ 1534, 439,
+ 1657, 1355,
+ 1788, 439
};
static int parser_goto_row55[] = {
10,
- -1, 71,
- 212, 432,
- 807, 432,
- 1089, 432,
- 1166, 1344,
- 1400, 432,
- 1482, 432,
- 1522, 432,
- 1645, 1344,
- 1776, 432
+ -1, 73,
+ 216, 440,
+ 815, 440,
+ 1097, 440,
+ 1176, 1356,
+ 1412, 440,
+ 1494, 440,
+ 1534, 440,
+ 1657, 1356,
+ 1788, 440
};
static int parser_goto_row56[] = {
10,
- -1, 72,
- 212, 433,
- 807, 433,
- 1089, 433,
- 1166, 1345,
- 1400, 433,
- 1482, 433,
- 1522, 433,
- 1645, 1345,
- 1776, 433
+ -1, 74,
+ 216, 441,
+ 815, 441,
+ 1097, 441,
+ 1176, 1357,
+ 1412, 441,
+ 1494, 441,
+ 1534, 441,
+ 1657, 1357,
+ 1788, 441
};
static int parser_goto_row57[] = {
2,
- -1, 394,
- 1051, 1209
+ -1, 402,
+ 1059, 1219
};
static int parser_goto_row58[] = {
10,
- -1, 73,
- 212, 434,
- 807, 434,
- 1089, 434,
- 1166, 1346,
- 1400, 434,
- 1482, 434,
- 1522, 434,
- 1645, 1346,
- 1776, 434
+ -1, 75,
+ 216, 442,
+ 815, 442,
+ 1097, 442,
+ 1176, 1358,
+ 1412, 442,
+ 1494, 442,
+ 1534, 442,
+ 1657, 1358,
+ 1788, 442
};
static int parser_goto_row59[] = {
2,
- -1, 201,
- 898, 1049
+ -1, 205,
+ 906, 1057
};
static int parser_goto_row60[] = {
131,
- -1, 435,
- 39, 180,
- 43, 202,
- 163, 336,
- 166, 338,
- 201, 385,
- 210, 395,
- 213, 448,
- 216, 453,
- 228, 454,
- 253, 481,
- 279, 505,
- 290, 514,
- 344, 555,
- 399, 607,
- 455, 635,
- 456, 636,
- 473, 514,
- 475, 674,
- 476, 675,
- 477, 676,
- 484, 679,
- 485, 680,
- 488, 682,
- 489, 683,
- 493, 686,
- 494, 687,
- 504, 514,
- 606, 802,
- 612, 453,
- 628, 814,
- 681, 514,
- 684, 859,
- 685, 860,
- 688, 861,
- 689, 862,
- 691, 863,
- 692, 864,
- 703, 871,
- 740, 884,
- 810, 682,
- 811, 686,
- 818, 966,
- 846, 1000,
- 847, 1001,
- 865, 1019,
- 866, 1020,
- 885, 1033,
- 894, 1046,
- 898, 1050,
- 922, 1068,
- 947, 1090,
- 953, 1095,
- 961, 863,
- 1002, 1174,
- 1003, 1175,
- 1004, 1176,
- 1005, 1177,
- 1007, 1178,
- 1008, 1179,
- 1012, 1182,
- 1013, 1183,
- 1021, 1191,
- 1026, 514,
- 1040, 1203,
- 1042, 1204,
- 1049, 1207,
- 1051, 395,
- 1069, 1225,
- 1091, 1243,
- 1096, 1000,
- 1180, 1361,
- 1181, 1362,
- 1184, 1363,
- 1185, 1364,
- 1187, 1365,
- 1188, 1366,
- 1246, 1178,
- 1247, 1182,
- 1249, 1408,
- 1250, 1410,
- 1252, 1411,
- 1329, 1478,
- 1367, 1495,
- 1368, 1496,
- 1385, 1508,
- 1407, 1365,
- 1483, 1592,
- 1484, 1593,
- 1594, 1667,
- 1595, 1668,
- 1596, 1669,
- 1597, 1670,
- 1598, 1671,
- 1599, 1672,
- 1602, 1680,
- 1603, 1681,
- 1604, 1682,
- 1605, 1683,
+ -1, 443,
+ 39, 184,
+ 43, 206,
+ 167, 344,
+ 170, 346,
+ 205, 393,
+ 214, 403,
+ 217, 456,
+ 220, 461,
+ 232, 462,
+ 259, 489,
+ 285, 513,
+ 296, 522,
+ 352, 563,
+ 407, 615,
+ 463, 643,
+ 464, 644,
+ 481, 522,
+ 483, 682,
+ 484, 683,
+ 485, 684,
+ 492, 687,
+ 493, 688,
+ 496, 690,
+ 497, 691,
+ 501, 694,
+ 502, 695,
+ 512, 522,
+ 614, 810,
+ 620, 461,
+ 636, 822,
+ 689, 522,
+ 692, 867,
+ 693, 868,
+ 696, 869,
+ 697, 870,
+ 699, 871,
+ 700, 872,
+ 711, 879,
+ 748, 892,
+ 818, 690,
+ 819, 694,
+ 826, 974,
+ 854, 1008,
+ 855, 1009,
+ 873, 1027,
+ 874, 1028,
+ 893, 1041,
+ 902, 1054,
+ 906, 1058,
+ 930, 1076,
+ 955, 1098,
+ 961, 1103,
+ 969, 871,
+ 1010, 1184,
+ 1011, 1185,
+ 1012, 1186,
+ 1013, 1187,
+ 1015, 1188,
+ 1016, 1189,
+ 1020, 1192,
+ 1021, 1193,
+ 1029, 1201,
+ 1034, 522,
+ 1048, 1213,
+ 1050, 1214,
+ 1057, 1217,
+ 1059, 403,
+ 1077, 1235,
+ 1099, 1253,
+ 1104, 1008,
+ 1190, 1373,
+ 1191, 1374,
+ 1194, 1375,
+ 1195, 1376,
+ 1197, 1377,
+ 1198, 1378,
+ 1256, 1188,
+ 1257, 1192,
+ 1259, 1420,
+ 1260, 1422,
+ 1262, 1423,
+ 1341, 1490,
+ 1379, 1507,
+ 1380, 1508,
+ 1397, 1520,
+ 1419, 1377,
+ 1495, 1604,
+ 1496, 1605,
+ 1606, 1679,
+ 1607, 1680,
+ 1608, 1681,
+ 1609, 1682,
+ 1610, 1683,
+ 1611, 1684,
+ 1614, 1692,
+ 1615, 1693,
1616, 1694,
- 1626, 1698,
- 1630, 966,
- 1665, 1746,
- 1673, 1748,
- 1674, 1749,
- 1684, 1757,
- 1685, 1758,
- 1686, 1759,
- 1687, 1760,
- 1701, 1768,
- 1750, 1802,
- 1751, 1803,
- 1761, 1815,
- 1762, 1816,
- 1793, 1838,
- 1804, 1844,
- 1805, 1845,
- 1806, 1846,
- 1807, 1847,
- 1808, 1848,
- 1809, 1849,
- 1811, 1852,
- 1812, 1853,
- 1850, 1874,
- 1851, 1875,
- 1854, 1876,
- 1855, 1877,
- 1856, 1878,
- 1857, 1879,
- 1880, 1891,
- 1881, 1892
+ 1617, 1695,
+ 1628, 1706,
+ 1638, 1710,
+ 1642, 974,
+ 1677, 1758,
+ 1685, 1760,
+ 1686, 1761,
+ 1696, 1769,
+ 1697, 1770,
+ 1698, 1771,
+ 1699, 1772,
+ 1713, 1780,
+ 1762, 1814,
+ 1763, 1815,
+ 1773, 1827,
+ 1774, 1828,
+ 1805, 1850,
+ 1816, 1856,
+ 1817, 1857,
+ 1818, 1858,
+ 1819, 1859,
+ 1820, 1860,
+ 1821, 1861,
+ 1823, 1864,
+ 1824, 1865,
+ 1862, 1886,
+ 1863, 1887,
+ 1866, 1888,
+ 1867, 1889,
+ 1868, 1890,
+ 1869, 1891,
+ 1892, 1903,
+ 1893, 1904
};
static int parser_goto_row61[] = {
1,
- -1, 181
+ -1, 185
};
static int parser_goto_row62[] = {
6,
- -1, 182,
- 345, 556,
- 561, 750,
- 563, 752,
- 564, 753,
- 751, 926
+ -1, 186,
+ 353, 564,
+ 569, 758,
+ 571, 760,
+ 572, 761,
+ 759, 934
};
static int parser_goto_row63[] = {
1,
- -1, 183
+ -1, 187
};
static int parser_goto_row64[] = {
8,
- -1, 184,
- 567, 756,
- 568, 757,
- 569, 758,
- 570, 759,
- 571, 760,
- 572, 761,
- 573, 762
+ -1, 188,
+ 575, 764,
+ 576, 765,
+ 577, 766,
+ 578, 767,
+ 579, 768,
+ 580, 769,
+ 581, 770
};
static int parser_goto_row65[] = {
2,
- -1, 185,
- 566, 755
+ -1, 189,
+ 574, 763
};
static int parser_goto_row66[] = {
2,
- -1, 186,
- 574, 763
+ -1, 190,
+ 582, 771
};
static int parser_goto_row67[] = {
2,
- -1, 187,
- 575, 764
+ -1, 191,
+ 583, 772
};
static int parser_goto_row68[] = {
3,
- -1, 188,
- 576, 765,
- 577, 766
+ -1, 192,
+ 584, 773,
+ 585, 774
};
static int parser_goto_row69[] = {
3,
- -1, 189,
- 578, 767,
- 579, 768
+ -1, 193,
+ 586, 775,
+ 587, 776
};
static int parser_goto_row70[] = {
5,
- -1, 190,
- 580, 769,
- 581, 770,
- 582, 771,
- 583, 772
+ -1, 194,
+ 588, 777,
+ 589, 778,
+ 590, 779,
+ 591, 780
};
static int parser_goto_row71[] = {
15,
- -1, 191,
- 127, 291,
- 128, 292,
- 129, 293,
- 176, 350,
- 177, 351,
- 178, 352,
- 282, 508,
- 347, 558,
- 405, 350,
- 406, 351,
- 414, 352,
- 1335, 291,
- 1336, 292,
- 1337, 293
+ -1, 195,
+ 129, 297,
+ 130, 298,
+ 131, 299,
+ 180, 358,
+ 181, 359,
+ 182, 360,
+ 288, 516,
+ 355, 566,
+ 413, 358,
+ 414, 359,
+ 422, 360,
+ 1347, 297,
+ 1348, 298,
+ 1349, 299
};
static int parser_goto_row72[] = {
1,
- -1, 192
+ -1, 196
};
static int parser_goto_row73[] = {
56,
- -1, 193,
- 13, 74,
- 27, 74,
- 33, 74,
- 37, 74,
- 98, 74,
- 160, 74,
- 175, 348,
- 212, 436,
- 242, 74,
- 386, 74,
- 472, 74,
- 545, 74,
- 588, 74,
- 591, 74,
- 738, 74,
- 742, 906,
- 743, 74,
- 798, 74,
- 807, 436,
- 888, 906,
- 890, 74,
- 892, 906,
- 909, 74,
- 979, 74,
- 1036, 74,
- 1058, 74,
- 1062, 74,
- 1089, 436,
- 1156, 74,
- 1208, 906,
- 1216, 74,
- 1380, 906,
- 1382, 74,
- 1393, 74,
- 1400, 436,
- 1482, 436,
- 1501, 906,
- 1502, 906,
- 1507, 906,
- 1522, 436,
- 1655, 74,
- 1659, 74,
- 1692, 906,
- 1721, 74,
- 1729, 74,
- 1730, 74,
- 1733, 74,
- 1738, 74,
- 1741, 74,
- 1776, 436,
- 1782, 74,
- 1789, 74,
- 1794, 74,
- 1799, 74,
- 1817, 906
+ -1, 197,
+ 13, 76,
+ 27, 76,
+ 33, 76,
+ 37, 76,
+ 100, 76,
+ 164, 76,
+ 179, 356,
+ 216, 444,
+ 248, 76,
+ 394, 76,
+ 480, 76,
+ 553, 76,
+ 596, 76,
+ 599, 76,
+ 746, 76,
+ 750, 914,
+ 751, 76,
+ 806, 76,
+ 815, 444,
+ 896, 914,
+ 898, 76,
+ 900, 914,
+ 917, 76,
+ 987, 76,
+ 1044, 76,
+ 1066, 76,
+ 1070, 76,
+ 1097, 444,
+ 1166, 76,
+ 1218, 914,
+ 1226, 76,
+ 1392, 914,
+ 1394, 76,
+ 1405, 76,
+ 1412, 444,
+ 1494, 444,
+ 1513, 914,
+ 1514, 914,
+ 1519, 914,
+ 1534, 444,
+ 1667, 76,
+ 1671, 76,
+ 1704, 914,
+ 1733, 76,
+ 1741, 76,
+ 1742, 76,
+ 1745, 76,
+ 1750, 76,
+ 1753, 76,
+ 1788, 444,
+ 1794, 76,
+ 1801, 76,
+ 1806, 76,
+ 1811, 76,
+ 1829, 914
};
static int parser_goto_row74[] = {
2,
- -1, 515,
- 1026, 1196
+ -1, 523,
+ 1034, 1206
};
static int parser_goto_row75[] = {
1,
- -1, 75
+ -1, 77
};
static int parser_goto_row76[] = {
31,
- -1, 76,
- 964, 1121,
- 1111, 1121,
- 1112, 1121,
- 1113, 1121,
- 1114, 1121,
- 1253, 1121,
- 1255, 1121,
- 1424, 1121,
- 1426, 1121,
- 1427, 1121,
- 1429, 1121,
- 1430, 1121,
- 1431, 1121,
- 1432, 1121,
- 1433, 1121,
- 1434, 1121,
- 1435, 1121,
- 1436, 1121,
- 1437, 1121,
- 1438, 1121,
- 1439, 1121,
- 1440, 1121,
- 1441, 1121,
- 1442, 1121,
- 1443, 1121,
- 1444, 1121,
- 1445, 1121,
- 1446, 1121,
- 1537, 1121,
- 1883, 1121
+ -1, 78,
+ 972, 1131,
+ 1119, 1131,
+ 1120, 1131,
+ 1121, 1131,
+ 1122, 1131,
+ 1263, 1131,
+ 1265, 1131,
+ 1436, 1131,
+ 1438, 1131,
+ 1439, 1131,
+ 1441, 1131,
+ 1442, 1131,
+ 1443, 1131,
+ 1444, 1131,
+ 1445, 1131,
+ 1446, 1131,
+ 1447, 1131,
+ 1448, 1131,
+ 1449, 1131,
+ 1450, 1131,
+ 1451, 1131,
+ 1452, 1131,
+ 1453, 1131,
+ 1454, 1131,
+ 1455, 1131,
+ 1456, 1131,
+ 1457, 1131,
+ 1458, 1131,
+ 1549, 1131,
+ 1895, 1131
};
static int parser_goto_row77[] = {
1,
- -1, 437
+ -1, 445
};
static int parser_goto_row78[] = {
2,
- -1, 616,
- 618, 809
+ -1, 624,
+ 626, 817
};
static int parser_goto_row79[] = {
1,
- -1, 449
+ -1, 457
};
static int parser_goto_row80[] = {
2,
- -1, 633,
- 634, 819
+ -1, 641,
+ 642, 827
};
static int parser_goto_row81[] = {
4,
- -1, 450,
- 818, 967,
- 1249, 1409,
- 1630, 1700
+ -1, 458,
+ 826, 975,
+ 1259, 1421,
+ 1642, 1712
};
static int parser_goto_row82[] = {
93,
- -1, 77,
- 31, 136,
- 54, 136,
- 125, 136,
- 254, 136,
- 256, 136,
- 257, 136,
- 258, 136,
- 259, 136,
- 280, 136,
- 497, 136,
- 498, 136,
- 519, 136,
- 521, 136,
- 522, 136,
- 524, 136,
- 525, 136,
- 526, 136,
- 527, 136,
- 528, 136,
- 529, 136,
- 530, 136,
- 531, 136,
- 532, 136,
- 533, 136,
- 534, 136,
- 535, 136,
- 536, 136,
- 537, 136,
- 538, 136,
- 539, 136,
- 540, 136,
- 541, 136,
- 668, 136,
- 670, 136,
- 708, 136,
- 851, 136,
- 852, 136,
- 853, 136,
- 854, 136,
- 887, 136,
- 901, 136,
- 964, 1122,
- 1016, 136,
- 1017, 136,
- 1055, 136,
- 1056, 136,
- 1057, 136,
- 1063, 136,
- 1064, 136,
- 1085, 136,
- 1111, 1122,
- 1112, 1122,
- 1113, 1122,
- 1114, 1122,
- 1166, 136,
- 1222, 136,
- 1223, 136,
- 1253, 1122,
- 1255, 1122,
- 1386, 136,
- 1387, 136,
- 1424, 1122,
- 1426, 1122,
- 1427, 1122,
- 1429, 1122,
- 1430, 1122,
- 1431, 1122,
- 1432, 1122,
- 1433, 1122,
- 1434, 1122,
- 1435, 1122,
- 1436, 1122,
- 1437, 1122,
- 1438, 1122,
- 1439, 1122,
- 1440, 1122,
- 1441, 1122,
- 1442, 1122,
- 1443, 1122,
- 1444, 1122,
- 1445, 1122,
- 1446, 1122,
- 1511, 136,
- 1512, 136,
- 1513, 136,
- 1514, 136,
- 1537, 1122,
- 1610, 136,
- 1623, 136,
- 1624, 136,
- 1645, 136,
- 1883, 1122
+ -1, 79,
+ 31, 140,
+ 54, 140,
+ 127, 140,
+ 260, 140,
+ 262, 140,
+ 263, 140,
+ 264, 140,
+ 265, 140,
+ 286, 140,
+ 505, 140,
+ 506, 140,
+ 527, 140,
+ 529, 140,
+ 530, 140,
+ 532, 140,
+ 533, 140,
+ 534, 140,
+ 535, 140,
+ 536, 140,
+ 537, 140,
+ 538, 140,
+ 539, 140,
+ 540, 140,
+ 541, 140,
+ 542, 140,
+ 543, 140,
+ 544, 140,
+ 545, 140,
+ 546, 140,
+ 547, 140,
+ 548, 140,
+ 549, 140,
+ 676, 140,
+ 678, 140,
+ 716, 140,
+ 859, 140,
+ 860, 140,
+ 861, 140,
+ 862, 140,
+ 895, 140,
+ 909, 140,
+ 972, 1132,
+ 1024, 140,
+ 1025, 140,
+ 1063, 140,
+ 1064, 140,
+ 1065, 140,
+ 1071, 140,
+ 1072, 140,
+ 1093, 140,
+ 1119, 1132,
+ 1120, 1132,
+ 1121, 1132,
+ 1122, 1132,
+ 1176, 140,
+ 1232, 140,
+ 1233, 140,
+ 1263, 1132,
+ 1265, 1132,
+ 1398, 140,
+ 1399, 140,
+ 1436, 1132,
+ 1438, 1132,
+ 1439, 1132,
+ 1441, 1132,
+ 1442, 1132,
+ 1443, 1132,
+ 1444, 1132,
+ 1445, 1132,
+ 1446, 1132,
+ 1447, 1132,
+ 1448, 1132,
+ 1449, 1132,
+ 1450, 1132,
+ 1451, 1132,
+ 1452, 1132,
+ 1453, 1132,
+ 1454, 1132,
+ 1455, 1132,
+ 1456, 1132,
+ 1457, 1132,
+ 1458, 1132,
+ 1523, 140,
+ 1524, 140,
+ 1525, 140,
+ 1526, 140,
+ 1549, 1132,
+ 1622, 140,
+ 1635, 140,
+ 1636, 140,
+ 1657, 140,
+ 1895, 1132
};
static int parser_goto_row83[] = {
1,
- -1, 78
+ -1, 80
};
static int parser_goto_row84[] = {
1,
- -1, 79
+ -1, 81
};
static int parser_goto_row85[] = {
2,
- -1, 249,
- 252, 479
+ -1, 255,
+ 258, 487
};
static int parser_goto_row86[] = {
1,
- -1, 250
+ -1, 256
};
static int parser_goto_row87[] = {
2,
- -1, 251,
- 252, 480
+ -1, 257,
+ 258, 488
};
static int parser_goto_row88[] = {
16,
- -1, 205,
- 162, 335,
- 212, 438,
- 393, 601,
- 807, 438,
- 1089, 438,
- 1148, 1306,
- 1166, 1347,
- 1324, 1467,
- 1400, 438,
- 1482, 438,
- 1522, 438,
- 1645, 1713,
- 1666, 1747,
- 1776, 438,
- 1865, 1886
+ -1, 209,
+ 166, 343,
+ 216, 446,
+ 401, 609,
+ 815, 446,
+ 1097, 446,
+ 1158, 1318,
+ 1176, 1359,
+ 1336, 1479,
+ 1412, 446,
+ 1494, 446,
+ 1534, 446,
+ 1657, 1725,
+ 1678, 1759,
+ 1788, 446,
+ 1877, 1898
};
static int parser_goto_row89[] = {
- 45,
- -1, 605,
- 45, 206,
- 46, 207,
- 47, 208,
- 48, 209,
- 55, 231,
- 56, 232,
- 57, 233,
- 58, 234,
- 60, 235,
- 121, 283,
- 122, 284,
- 123, 285,
- 124, 286,
- 131, 295,
- 132, 296,
- 133, 297,
- 134, 298,
- 135, 299,
- 251, 478,
- 480, 677,
- 603, 800,
- 795, 946,
- 806, 958,
- 808, 960,
- 817, 965,
- 1085, 1237,
- 1107, 1256,
- 1108, 1257,
- 1109, 1258,
- 1110, 1259,
+ 51,
+ -1, 613,
+ 45, 210,
+ 46, 211,
+ 47, 212,
+ 48, 213,
+ 55, 235,
+ 56, 236,
+ 57, 237,
+ 58, 238,
+ 59, 239,
+ 60, 240,
+ 62, 241,
+ 123, 289,
+ 124, 290,
+ 125, 291,
+ 126, 292,
+ 133, 301,
+ 134, 302,
+ 135, 303,
+ 136, 304,
+ 137, 305,
+ 138, 306,
+ 139, 307,
+ 257, 486,
+ 488, 685,
+ 611, 808,
+ 803, 954,
+ 814, 966,
+ 816, 968,
+ 825, 973,
+ 1093, 1247,
+ 1115, 1266,
1116, 1267,
1117, 1268,
1118, 1269,
- 1119, 1270,
- 1120, 1271,
- 1148, 1307,
- 1245, 1406,
- 1405, 1524,
- 1422, 1534,
- 1423, 1535,
- 1521, 1628,
- 1541, 1637,
- 1636, 1706,
- 1699, 1767
+ 1124, 1277,
+ 1125, 1278,
+ 1126, 1279,
+ 1127, 1280,
+ 1128, 1281,
+ 1129, 1282,
+ 1130, 1283,
+ 1158, 1319,
+ 1255, 1418,
+ 1417, 1536,
+ 1434, 1546,
+ 1435, 1547,
+ 1533, 1640,
+ 1553, 1649,
+ 1648, 1718,
+ 1711, 1779
};
static int parser_goto_row90[] = {
1,
- -1, 392
+ -1, 400
};
static int parser_goto_row91[] = {
6,
- -1, 790,
- 935, 1079,
- 969, 1144,
- 978, 1153,
- 1654, 1726,
- 1732, 1790
+ -1, 798,
+ 943, 1087,
+ 977, 1154,
+ 986, 1163,
+ 1666, 1738,
+ 1744, 1802
};
static int parser_goto_row92[] = {
2,
- -1, 791,
- 1087, 1240
+ -1, 799,
+ 1095, 1250
};
static int parser_goto_row93[] = {
1,
- -1, 1238
+ -1, 1248
};
static int parser_goto_row94[] = {
2,
- -1, 943,
- 944, 1088
+ -1, 951,
+ 952, 1096
};
static int parser_goto_row95[] = {
5,
- -1, 1302,
- 1304, 1452,
- 1319, 1452,
- 1785, 1452,
- 1836, 1452
+ -1, 1314,
+ 1316, 1464,
+ 1331, 1464,
+ 1797, 1464,
+ 1848, 1464
};
static int parser_goto_row96[] = {
1,
- -1, 991
+ -1, 999
};
static int parser_goto_row97[] = {
4,
- -1, 1241,
- 1400, 1520,
- 1482, 1591,
- 1776, 1825
+ -1, 1251,
+ 1412, 1532,
+ 1494, 1603,
+ 1788, 1837
};
static int parser_goto_row98[] = {
3,
- -1, 1403,
- 1404, 1523,
- 1490, 1523
+ -1, 1415,
+ 1416, 1535,
+ 1502, 1535
};
static int parser_goto_row99[] = {
4,
- -1, 1242,
- 212, 439,
- 807, 959,
- 1522, 1629
+ -1, 1252,
+ 216, 447,
+ 815, 967,
+ 1534, 1641
};
static int parser_goto_row100[] = {
4,
- -1, 795,
- 936, 1080,
- 940, 1085,
- 1568, 1645
+ -1, 803,
+ 944, 1088,
+ 948, 1093,
+ 1580, 1657
};
static int parser_goto_row101[] = {
86,
- -1, 353,
- 31, 137,
- 54, 229,
- 116, 278,
- 130, 294,
- 170, 137,
- 254, 482,
- 257, 490,
- 259, 495,
- 300, 517,
- 302, 518,
- 327, 543,
- 378, 482,
- 380, 585,
- 381, 586,
- 425, 229,
- 498, 693,
- 507, 700,
- 544, 736,
- 557, 748,
- 587, 778,
- 623, 490,
- 625, 495,
- 668, 843,
- 670, 848,
- 730, 876,
- 732, 878,
- 773, 843,
- 774, 927,
- 812, 693,
- 852, 1009,
- 854, 1014,
- 880, 1030,
- 881, 1031,
- 887, 137,
- 901, 229,
- 929, 1071,
- 930, 1072,
- 937, 1081,
- 954, 848,
- 1017, 1189,
- 1022, 1192,
- 1032, 1199,
- 1055, 482,
- 1057, 490,
- 1064, 495,
- 1073, 1226,
- 1082, 1233,
- 1083, 1234,
- 1097, 1009,
- 1098, 1014,
- 1102, 1251,
- 1115, 1266,
- 1193, 1370,
- 1194, 1371,
- 1223, 693,
- 1235, 1399,
- 1248, 1189,
- 1272, 1420,
- 1274, 1421,
- 1299, 1448,
- 1338, 1485,
- 1372, 1498,
- 1386, 843,
- 1387, 848,
- 1415, 1531,
- 1449, 1567,
- 1487, 1600,
- 1491, 1606,
- 1512, 1009,
- 1514, 1014,
- 1561, 1638,
- 1563, 1640,
- 1607, 1688,
- 1624, 1189,
- 1642, 1709,
- 1643, 1710,
- 1675, 1752,
- 1702, 1769,
- 1711, 1775,
- 1754, 1810,
- 1755, 1813,
- 1770, 1819,
- 1771, 1820,
- 1814, 1858,
- 1821, 1862
+ -1, 361,
+ 31, 141,
+ 54, 233,
+ 118, 284,
+ 132, 300,
+ 174, 141,
+ 260, 490,
+ 263, 498,
+ 265, 503,
+ 308, 525,
+ 310, 526,
+ 335, 551,
+ 386, 490,
+ 388, 593,
+ 389, 594,
+ 433, 233,
+ 506, 701,
+ 515, 708,
+ 552, 744,
+ 565, 756,
+ 595, 786,
+ 631, 498,
+ 633, 503,
+ 676, 851,
+ 678, 856,
+ 738, 884,
+ 740, 886,
+ 781, 851,
+ 782, 935,
+ 820, 701,
+ 860, 1017,
+ 862, 1022,
+ 888, 1038,
+ 889, 1039,
+ 895, 141,
+ 909, 233,
+ 937, 1079,
+ 938, 1080,
+ 945, 1089,
+ 962, 856,
+ 1025, 1199,
+ 1030, 1202,
+ 1040, 1209,
+ 1063, 490,
+ 1065, 498,
+ 1072, 503,
+ 1081, 1236,
+ 1090, 1243,
+ 1091, 1244,
+ 1105, 1017,
+ 1106, 1022,
+ 1110, 1261,
+ 1123, 1276,
+ 1203, 1382,
+ 1204, 1383,
+ 1233, 701,
+ 1245, 1411,
+ 1258, 1199,
+ 1284, 1432,
+ 1286, 1433,
+ 1311, 1460,
+ 1350, 1497,
+ 1384, 1510,
+ 1398, 851,
+ 1399, 856,
+ 1427, 1543,
+ 1461, 1579,
+ 1499, 1612,
+ 1503, 1618,
+ 1524, 1017,
+ 1526, 1022,
+ 1573, 1650,
+ 1575, 1652,
+ 1619, 1700,
+ 1636, 1199,
+ 1654, 1721,
+ 1655, 1722,
+ 1687, 1764,
+ 1714, 1781,
+ 1723, 1787,
+ 1766, 1822,
+ 1767, 1825,
+ 1782, 1831,
+ 1783, 1832,
+ 1826, 1870,
+ 1833, 1874
};
static int parser_goto_row102[] = {
34,
- -1, 138,
- 54, 230,
- 254, 483,
- 256, 487,
- 257, 491,
- 258, 492,
- 259, 496,
- 497, 690,
- 498, 694,
- 668, 844,
- 670, 849,
- 851, 1006,
- 852, 1010,
- 853, 1011,
- 854, 1015,
- 887, 1034,
- 901, 1053,
- 1016, 1186,
- 1017, 1190,
- 1055, 1212,
- 1056, 1213,
- 1057, 1214,
- 1063, 1220,
- 1064, 1221,
- 1222, 1391,
- 1223, 1392,
- 1386, 1509,
- 1387, 1510,
- 1511, 1619,
- 1512, 1620,
- 1513, 1621,
- 1514, 1622,
- 1623, 1696,
- 1624, 1697
+ -1, 142,
+ 54, 234,
+ 260, 491,
+ 262, 495,
+ 263, 499,
+ 264, 500,
+ 265, 504,
+ 505, 698,
+ 506, 702,
+ 676, 852,
+ 678, 857,
+ 859, 1014,
+ 860, 1018,
+ 861, 1019,
+ 862, 1023,
+ 895, 1042,
+ 909, 1061,
+ 1024, 1196,
+ 1025, 1200,
+ 1063, 1222,
+ 1064, 1223,
+ 1065, 1224,
+ 1071, 1230,
+ 1072, 1231,
+ 1232, 1403,
+ 1233, 1404,
+ 1398, 1521,
+ 1399, 1522,
+ 1523, 1631,
+ 1524, 1632,
+ 1525, 1633,
+ 1526, 1634,
+ 1635, 1708,
+ 1636, 1709
};
static int parser_goto_row103[] = {
6,
- -1, 246,
- 154, 326,
- 193, 377,
- 289, 326,
- 348, 377,
- 1353, 1489
+ -1, 252,
+ 158, 334,
+ 197, 385,
+ 295, 334,
+ 356, 385,
+ 1365, 1501
};
static int parser_goto_row104[] = {
4,
- -1, 516,
- 473, 667,
- 504, 697,
- 681, 858
+ -1, 524,
+ 481, 675,
+ 512, 705,
+ 689, 866
};
static int parser_goto_row105[] = {
2,
- -1, 873,
- 874, 1027
+ -1, 881,
+ 882, 1035
};
static int parser_goto_row106[] = {
3,
- -1, 342,
- 629, 815,
- 1045, 1206
+ -1, 350,
+ 637, 823,
+ 1053, 1216
};
static int parser_goto_row107[] = {
2,
- -1, 343,
- 552, 744
+ -1, 351,
+ 560, 752
};
static int parser_goto_row108[] = {
2,
- -1, 822,
- 638, 825
+ -1, 830,
+ 646, 833
};
static int parser_goto_row109[] = {
157,
- -1, 194,
- 13, 80,
- 27, 80,
- 31, 139,
- 33, 80,
- 37, 80,
- 54, 139,
- 98, 80,
- 125, 288,
- 160, 80,
- 175, 349,
- 212, 440,
- 242, 80,
- 254, 139,
- 256, 139,
- 257, 139,
- 258, 139,
- 259, 139,
- 280, 139,
- 386, 80,
- 472, 80,
- 474, 671,
- 497, 139,
- 498, 139,
- 519, 139,
- 521, 139,
- 522, 139,
- 524, 139,
- 525, 139,
- 526, 139,
- 527, 139,
- 528, 139,
- 529, 139,
- 530, 139,
- 531, 139,
- 532, 139,
- 533, 139,
- 534, 139,
- 535, 139,
- 536, 139,
- 537, 139,
- 538, 139,
- 539, 139,
- 540, 139,
- 541, 139,
- 542, 733,
- 545, 80,
- 584, 775,
- 588, 80,
- 591, 80,
- 668, 139,
- 670, 139,
- 702, 870,
- 708, 139,
- 738, 80,
- 742, 907,
- 743, 80,
- 749, 925,
- 798, 80,
- 805, 671,
- 807, 440,
- 851, 139,
- 852, 139,
- 853, 139,
- 854, 139,
- 887, 139,
- 888, 907,
- 890, 80,
- 892, 907,
- 901, 139,
- 909, 80,
- 964, 1123,
- 979, 80,
- 1016, 139,
- 1017, 139,
- 1036, 80,
- 1055, 139,
- 1056, 139,
- 1057, 139,
- 1058, 80,
- 1062, 80,
- 1063, 139,
- 1064, 139,
- 1089, 440,
- 1111, 1261,
- 1112, 1123,
- 1113, 1123,
- 1114, 1123,
- 1156, 80,
- 1166, 1348,
- 1208, 907,
- 1211, 671,
- 1216, 80,
- 1222, 139,
- 1223, 139,
- 1253, 1123,
- 1255, 1123,
- 1380, 907,
- 1382, 80,
- 1386, 139,
- 1387, 139,
- 1393, 80,
- 1400, 440,
- 1424, 1123,
- 1426, 1123,
- 1427, 1123,
- 1429, 1123,
- 1430, 1123,
- 1431, 1123,
- 1432, 1123,
- 1433, 1123,
- 1434, 1123,
- 1435, 1123,
- 1436, 1123,
- 1437, 1123,
- 1438, 1123,
- 1439, 1123,
- 1440, 1123,
- 1441, 1123,
- 1442, 1123,
- 1443, 1123,
- 1444, 1123,
- 1445, 1123,
- 1446, 1123,
- 1447, 1564,
- 1482, 440,
- 1501, 907,
- 1502, 907,
- 1507, 907,
- 1511, 139,
- 1512, 139,
- 1513, 139,
- 1514, 139,
- 1522, 440,
- 1533, 1634,
- 1537, 1123,
- 1601, 1676,
- 1610, 139,
- 1623, 139,
- 1624, 139,
- 1645, 1348,
- 1655, 80,
- 1659, 80,
- 1692, 907,
- 1721, 80,
- 1729, 80,
- 1730, 80,
- 1733, 80,
- 1738, 80,
- 1741, 80,
- 1776, 440,
- 1782, 80,
- 1789, 80,
- 1794, 80,
- 1799, 80,
- 1817, 907,
- 1883, 1123
+ -1, 198,
+ 13, 82,
+ 27, 82,
+ 31, 143,
+ 33, 82,
+ 37, 82,
+ 54, 143,
+ 100, 82,
+ 127, 294,
+ 164, 82,
+ 179, 357,
+ 216, 448,
+ 248, 82,
+ 260, 143,
+ 262, 143,
+ 263, 143,
+ 264, 143,
+ 265, 143,
+ 286, 143,
+ 394, 82,
+ 480, 82,
+ 482, 679,
+ 505, 143,
+ 506, 143,
+ 527, 143,
+ 529, 143,
+ 530, 143,
+ 532, 143,
+ 533, 143,
+ 534, 143,
+ 535, 143,
+ 536, 143,
+ 537, 143,
+ 538, 143,
+ 539, 143,
+ 540, 143,
+ 541, 143,
+ 542, 143,
+ 543, 143,
+ 544, 143,
+ 545, 143,
+ 546, 143,
+ 547, 143,
+ 548, 143,
+ 549, 143,
+ 550, 741,
+ 553, 82,
+ 592, 783,
+ 596, 82,
+ 599, 82,
+ 676, 143,
+ 678, 143,
+ 710, 878,
+ 716, 143,
+ 746, 82,
+ 750, 915,
+ 751, 82,
+ 757, 933,
+ 806, 82,
+ 813, 679,
+ 815, 448,
+ 859, 143,
+ 860, 143,
+ 861, 143,
+ 862, 143,
+ 895, 143,
+ 896, 915,
+ 898, 82,
+ 900, 915,
+ 909, 143,
+ 917, 82,
+ 972, 1133,
+ 987, 82,
+ 1024, 143,
+ 1025, 143,
+ 1044, 82,
+ 1063, 143,
+ 1064, 143,
+ 1065, 143,
+ 1066, 82,
+ 1070, 82,
+ 1071, 143,
+ 1072, 143,
+ 1097, 448,
+ 1119, 1271,
+ 1120, 1133,
+ 1121, 1133,
+ 1122, 1133,
+ 1166, 82,
+ 1176, 1360,
+ 1218, 915,
+ 1221, 679,
+ 1226, 82,
+ 1232, 143,
+ 1233, 143,
+ 1263, 1133,
+ 1265, 1133,
+ 1392, 915,
+ 1394, 82,
+ 1398, 143,
+ 1399, 143,
+ 1405, 82,
+ 1412, 448,
+ 1436, 1133,
+ 1438, 1133,
+ 1439, 1133,
+ 1441, 1133,
+ 1442, 1133,
+ 1443, 1133,
+ 1444, 1133,
+ 1445, 1133,
+ 1446, 1133,
+ 1447, 1133,
+ 1448, 1133,
+ 1449, 1133,
+ 1450, 1133,
+ 1451, 1133,
+ 1452, 1133,
+ 1453, 1133,
+ 1454, 1133,
+ 1455, 1133,
+ 1456, 1133,
+ 1457, 1133,
+ 1458, 1133,
+ 1459, 1576,
+ 1494, 448,
+ 1513, 915,
+ 1514, 915,
+ 1519, 915,
+ 1523, 143,
+ 1524, 143,
+ 1525, 143,
+ 1526, 143,
+ 1534, 448,
+ 1545, 1646,
+ 1549, 1133,
+ 1613, 1688,
+ 1622, 143,
+ 1635, 143,
+ 1636, 143,
+ 1657, 1360,
+ 1667, 82,
+ 1671, 82,
+ 1704, 915,
+ 1733, 82,
+ 1741, 82,
+ 1742, 82,
+ 1745, 82,
+ 1750, 82,
+ 1753, 82,
+ 1788, 448,
+ 1794, 82,
+ 1801, 82,
+ 1806, 82,
+ 1811, 82,
+ 1829, 915,
+ 1895, 1133
};
static int parser_goto_row110[] = {
1,
- -1, 839
+ -1, 847
};
static int parser_goto_row111[] = {
6,
- -1, 1318,
- 467, 662,
- 1463, 1575,
- 1472, 1582,
- 1474, 1585,
- 1476, 1588
+ -1, 1330,
+ 475, 670,
+ 1475, 1587,
+ 1484, 1594,
+ 1486, 1597,
+ 1488, 1600
};
static int parser_goto_row112[] = {
22,
- -1, 81,
- 83, 260,
- 156, 260,
- 196, 260,
- 445, 260,
- 664, 260,
- 673, 260,
- 735, 260,
- 777, 260,
- 823, 260,
- 841, 260,
- 918, 260,
- 939, 260,
- 957, 260,
- 1024, 260,
- 1140, 260,
- 1143, 260,
- 1357, 260,
- 1389, 260,
- 1566, 260,
- 1679, 260,
- 1704, 260
+ -1, 83,
+ 85, 266,
+ 160, 266,
+ 200, 266,
+ 453, 266,
+ 672, 266,
+ 681, 266,
+ 743, 266,
+ 785, 266,
+ 831, 266,
+ 849, 266,
+ 926, 266,
+ 947, 266,
+ 965, 266,
+ 1032, 266,
+ 1150, 266,
+ 1153, 266,
+ 1369, 266,
+ 1401, 266,
+ 1578, 266,
+ 1691, 266,
+ 1716, 266
};
static int parser_goto_row113[] = {
186,
- -1, 195,
- 13, 82,
- 27, 82,
- 31, 140,
- 33, 82,
- 37, 82,
- 54, 140,
- 83, 261,
- 98, 82,
- 125, 140,
- 156, 328,
- 160, 82,
- 196, 382,
- 212, 441,
- 242, 82,
- 254, 140,
- 256, 140,
- 257, 140,
- 258, 140,
- 259, 140,
- 280, 140,
- 386, 82,
- 445, 626,
- 467, 663,
- 472, 82,
- 474, 672,
- 497, 140,
- 498, 140,
- 519, 140,
- 521, 140,
- 522, 140,
- 524, 140,
- 525, 140,
- 526, 140,
- 527, 140,
- 528, 140,
- 529, 140,
- 530, 140,
- 531, 140,
- 532, 140,
- 533, 140,
- 534, 140,
- 535, 140,
- 536, 140,
- 537, 140,
- 538, 140,
- 539, 140,
- 540, 140,
- 541, 140,
- 542, 734,
- 545, 82,
- 584, 776,
- 588, 82,
- 591, 82,
- 664, 836,
- 666, 840,
- 668, 140,
- 670, 140,
- 673, 855,
- 702, 734,
- 708, 140,
- 735, 882,
- 738, 82,
- 742, 908,
- 743, 82,
- 749, 776,
- 777, 931,
- 788, 938,
- 798, 82,
- 805, 955,
- 807, 441,
- 841, 997,
- 851, 140,
- 852, 140,
- 853, 140,
- 854, 140,
- 869, 1023,
- 887, 140,
- 888, 908,
- 890, 82,
- 892, 908,
- 901, 140,
- 909, 82,
- 918, 1065,
- 939, 1084,
- 957, 1099,
- 964, 1124,
- 979, 82,
- 1016, 140,
- 1017, 140,
- 1024, 1195,
- 1036, 82,
- 1055, 140,
- 1056, 140,
- 1057, 140,
- 1058, 82,
- 1062, 82,
- 1063, 140,
- 1064, 140,
- 1089, 441,
- 1111, 1124,
- 1112, 1124,
- 1113, 1124,
- 1114, 1124,
- 1140, 1300,
- 1152, 663,
- 1156, 82,
- 1166, 1349,
- 1208, 908,
- 1211, 1388,
- 1216, 82,
- 1222, 140,
- 1223, 140,
- 1253, 1124,
- 1255, 1124,
- 1357, 1492,
- 1380, 908,
- 1382, 82,
- 1386, 140,
- 1387, 140,
- 1389, 1515,
- 1393, 82,
- 1400, 441,
- 1424, 1124,
- 1426, 1124,
- 1427, 1124,
- 1429, 1124,
- 1430, 1124,
- 1431, 1124,
- 1432, 1124,
- 1433, 1124,
- 1434, 1124,
- 1435, 1124,
- 1436, 1124,
- 1437, 1124,
- 1438, 1124,
- 1439, 1124,
- 1440, 1124,
- 1441, 1124,
- 1442, 1124,
- 1443, 1124,
- 1444, 1124,
- 1445, 1124,
- 1446, 1124,
- 1447, 1565,
- 1463, 663,
- 1472, 663,
- 1474, 663,
- 1476, 663,
- 1482, 441,
- 1501, 908,
- 1502, 908,
- 1507, 908,
- 1511, 140,
- 1512, 140,
- 1513, 140,
- 1514, 140,
- 1522, 441,
- 1533, 1565,
- 1537, 1124,
- 1566, 1644,
- 1572, 663,
- 1601, 1677,
- 1610, 140,
- 1623, 140,
- 1624, 140,
- 1633, 1703,
- 1645, 1349,
- 1655, 82,
- 1659, 82,
- 1679, 1756,
- 1692, 908,
- 1704, 1772,
- 1721, 82,
- 1729, 82,
- 1730, 82,
- 1733, 82,
- 1738, 82,
- 1741, 82,
- 1776, 441,
- 1782, 82,
- 1789, 82,
- 1794, 82,
- 1799, 82,
- 1817, 908,
- 1883, 1124
+ -1, 199,
+ 13, 84,
+ 27, 84,
+ 31, 144,
+ 33, 84,
+ 37, 84,
+ 54, 144,
+ 85, 267,
+ 100, 84,
+ 127, 144,
+ 160, 336,
+ 164, 84,
+ 200, 390,
+ 216, 449,
+ 248, 84,
+ 260, 144,
+ 262, 144,
+ 263, 144,
+ 264, 144,
+ 265, 144,
+ 286, 144,
+ 394, 84,
+ 453, 634,
+ 475, 671,
+ 480, 84,
+ 482, 680,
+ 505, 144,
+ 506, 144,
+ 527, 144,
+ 529, 144,
+ 530, 144,
+ 532, 144,
+ 533, 144,
+ 534, 144,
+ 535, 144,
+ 536, 144,
+ 537, 144,
+ 538, 144,
+ 539, 144,
+ 540, 144,
+ 541, 144,
+ 542, 144,
+ 543, 144,
+ 544, 144,
+ 545, 144,
+ 546, 144,
+ 547, 144,
+ 548, 144,
+ 549, 144,
+ 550, 742,
+ 553, 84,
+ 592, 784,
+ 596, 84,
+ 599, 84,
+ 672, 844,
+ 674, 848,
+ 676, 144,
+ 678, 144,
+ 681, 863,
+ 710, 742,
+ 716, 144,
+ 743, 890,
+ 746, 84,
+ 750, 916,
+ 751, 84,
+ 757, 784,
+ 785, 939,
+ 796, 946,
+ 806, 84,
+ 813, 963,
+ 815, 449,
+ 849, 1005,
+ 859, 144,
+ 860, 144,
+ 861, 144,
+ 862, 144,
+ 877, 1031,
+ 895, 144,
+ 896, 916,
+ 898, 84,
+ 900, 916,
+ 909, 144,
+ 917, 84,
+ 926, 1073,
+ 947, 1092,
+ 965, 1107,
+ 972, 1134,
+ 987, 84,
+ 1024, 144,
+ 1025, 144,
+ 1032, 1205,
+ 1044, 84,
+ 1063, 144,
+ 1064, 144,
+ 1065, 144,
+ 1066, 84,
+ 1070, 84,
+ 1071, 144,
+ 1072, 144,
+ 1097, 449,
+ 1119, 1134,
+ 1120, 1134,
+ 1121, 1134,
+ 1122, 1134,
+ 1150, 1312,
+ 1162, 671,
+ 1166, 84,
+ 1176, 1361,
+ 1218, 916,
+ 1221, 1400,
+ 1226, 84,
+ 1232, 144,
+ 1233, 144,
+ 1263, 1134,
+ 1265, 1134,
+ 1369, 1504,
+ 1392, 916,
+ 1394, 84,
+ 1398, 144,
+ 1399, 144,
+ 1401, 1527,
+ 1405, 84,
+ 1412, 449,
+ 1436, 1134,
+ 1438, 1134,
+ 1439, 1134,
+ 1441, 1134,
+ 1442, 1134,
+ 1443, 1134,
+ 1444, 1134,
+ 1445, 1134,
+ 1446, 1134,
+ 1447, 1134,
+ 1448, 1134,
+ 1449, 1134,
+ 1450, 1134,
+ 1451, 1134,
+ 1452, 1134,
+ 1453, 1134,
+ 1454, 1134,
+ 1455, 1134,
+ 1456, 1134,
+ 1457, 1134,
+ 1458, 1134,
+ 1459, 1577,
+ 1475, 671,
+ 1484, 671,
+ 1486, 671,
+ 1488, 671,
+ 1494, 449,
+ 1513, 916,
+ 1514, 916,
+ 1519, 916,
+ 1523, 144,
+ 1524, 144,
+ 1525, 144,
+ 1526, 144,
+ 1534, 449,
+ 1545, 1577,
+ 1549, 1134,
+ 1578, 1656,
+ 1584, 671,
+ 1613, 1689,
+ 1622, 144,
+ 1635, 144,
+ 1636, 144,
+ 1645, 1715,
+ 1657, 1361,
+ 1667, 84,
+ 1671, 84,
+ 1691, 1768,
+ 1704, 916,
+ 1716, 1784,
+ 1733, 84,
+ 1741, 84,
+ 1742, 84,
+ 1745, 84,
+ 1750, 84,
+ 1753, 84,
+ 1788, 449,
+ 1794, 84,
+ 1801, 84,
+ 1806, 84,
+ 1811, 84,
+ 1829, 916,
+ 1895, 1134
};
static int parser_goto_row114[] = {
12,
- -1, 1321,
- 1322, 1465,
- 1728, 1786,
- 1737, 1795,
- 1781, 1830,
- 1787, 1833,
- 1788, 1834,
- 1796, 1840,
- 1798, 1841,
- 1831, 1869,
- 1835, 1870,
- 1842, 1873
+ -1, 1333,
+ 1334, 1477,
+ 1740, 1798,
+ 1749, 1807,
+ 1793, 1842,
+ 1799, 1845,
+ 1800, 1846,
+ 1808, 1852,
+ 1810, 1853,
+ 1843, 1881,
+ 1847, 1882,
+ 1854, 1885
};
static int parser_goto_row115[] = {
14,
- -1, 91,
- 824, 972,
- 969, 1145,
- 970, 1146,
- 973, 1147,
- 978, 1154,
- 989, 1161,
- 1645, 1714,
- 1654, 1727,
- 1713, 1777,
- 1715, 1778,
- 1732, 1791,
- 1865, 1887,
- 1886, 1895
+ -1, 93,
+ 832, 980,
+ 977, 1155,
+ 978, 1156,
+ 981, 1157,
+ 986, 1164,
+ 997, 1171,
+ 1657, 1726,
+ 1666, 1739,
+ 1725, 1789,
+ 1727, 1790,
+ 1744, 1803,
+ 1877, 1899,
+ 1898, 1907
};
static int parser_goto_row116[] = {
55,
- -1, 591,
+ -1, 599,
0, 12,
3, 23,
5, 12,
28, 12,
29, 12,
30, 12,
- 33, 160,
- 37, 160,
- 64, 242,
- 94, 12,
- 95, 12,
- 99, 12,
- 104, 269,
- 105, 270,
- 111, 12,
- 112, 12,
+ 33, 164,
+ 37, 164,
+ 66, 248,
+ 96, 12,
+ 97, 12,
+ 101, 12,
+ 106, 275,
+ 107, 276,
+ 113, 12,
114, 12,
- 243, 472,
- 265, 12,
- 271, 502,
- 274, 12,
- 331, 545,
- 546, 738,
- 742, 909,
- 743, 160,
- 798, 160,
- 839, 992,
- 888, 1036,
- 892, 1036,
- 990, 992,
- 994, 992,
- 1060, 242,
- 1145, 992,
- 1154, 992,
- 1208, 1382,
- 1218, 472,
- 1304, 992,
- 1319, 992,
- 1380, 1382,
- 1393, 160,
- 1468, 992,
- 1501, 909,
- 1502, 1036,
- 1507, 1036,
- 1579, 992,
- 1692, 1382,
- 1727, 992,
- 1785, 992,
- 1791, 992,
- 1817, 1036,
- 1836, 992
+ 116, 12,
+ 249, 480,
+ 271, 12,
+ 277, 510,
+ 280, 12,
+ 339, 553,
+ 554, 746,
+ 750, 917,
+ 751, 164,
+ 806, 164,
+ 847, 1000,
+ 896, 1044,
+ 900, 1044,
+ 998, 1000,
+ 1002, 1000,
+ 1068, 248,
+ 1155, 1000,
+ 1164, 1000,
+ 1218, 1394,
+ 1228, 480,
+ 1316, 1000,
+ 1331, 1000,
+ 1392, 1394,
+ 1405, 164,
+ 1480, 1000,
+ 1513, 917,
+ 1514, 1044,
+ 1519, 1044,
+ 1591, 1000,
+ 1704, 1394,
+ 1739, 1000,
+ 1797, 1000,
+ 1803, 1000,
+ 1829, 1044,
+ 1848, 1000
};
static int parser_goto_row117[] = {
18,
- -1, 98,
+ -1, 100,
0, 13,
5, 27,
18, 27,
28, 27,
- 839, 993,
- 990, 993,
- 994, 1169,
- 1145, 1303,
- 1154, 1303,
- 1304, 1303,
- 1319, 1303,
- 1468, 993,
- 1579, 993,
- 1727, 1303,
- 1785, 1303,
- 1791, 1303,
- 1836, 1303
+ 847, 1001,
+ 998, 1001,
+ 1002, 1179,
+ 1155, 1315,
+ 1164, 1315,
+ 1316, 1315,
+ 1331, 1315,
+ 1480, 1001,
+ 1591, 1001,
+ 1739, 1315,
+ 1797, 1315,
+ 1803, 1315,
+ 1848, 1315
};
static int parser_goto_row118[] = {
249,
-1, 14,
- 35, 163,
- 36, 166,
- 38, 169,
- 44, 203,
- 49, 210,
- 51, 212,
- 52, 213,
- 79, 253,
- 84, 262,
- 117, 279,
- 118, 280,
- 119, 281,
- 120, 282,
- 126, 290,
- 171, 344,
- 172, 345,
- 173, 346,
- 174, 347,
- 214, 451,
- 215, 452,
- 236, 457,
- 237, 458,
- 238, 459,
- 239, 460,
- 244, 473,
- 245, 474,
- 250, 477,
- 277, 504,
- 287, 509,
- 303, 519,
- 304, 521,
- 305, 522,
- 306, 523,
- 307, 524,
- 308, 525,
- 309, 526,
- 310, 527,
- 311, 528,
+ 35, 167,
+ 36, 170,
+ 38, 173,
+ 44, 207,
+ 49, 214,
+ 51, 216,
+ 52, 217,
+ 81, 259,
+ 86, 268,
+ 119, 285,
+ 120, 286,
+ 121, 287,
+ 122, 288,
+ 128, 296,
+ 175, 352,
+ 176, 353,
+ 177, 354,
+ 178, 355,
+ 218, 459,
+ 219, 460,
+ 242, 465,
+ 243, 466,
+ 244, 467,
+ 245, 468,
+ 250, 481,
+ 251, 482,
+ 256, 485,
+ 283, 512,
+ 293, 517,
+ 311, 527,
312, 529,
313, 530,
314, 531,
323, 540,
324, 541,
325, 542,
- 333, 547,
- 336, 550,
- 338, 551,
- 340, 552,
- 342, 553,
- 354, 561,
- 355, 563,
- 356, 564,
- 357, 565,
- 358, 566,
- 359, 567,
- 360, 568,
- 361, 569,
- 362, 570,
+ 326, 543,
+ 327, 544,
+ 328, 545,
+ 329, 546,
+ 330, 547,
+ 331, 548,
+ 332, 549,
+ 333, 550,
+ 341, 555,
+ 344, 558,
+ 346, 559,
+ 348, 560,
+ 350, 561,
+ 362, 569,
363, 571,
364, 572,
365, 573,
374, 582,
375, 583,
376, 584,
- 390, 598,
- 394, 602,
- 404, 213,
- 437, 614,
- 439, 617,
- 446, 628,
- 447, 629,
- 448, 630,
- 461, 637,
- 462, 638,
- 469, 666,
- 481, 678,
- 486, 681,
- 499, 695,
- 505, 698,
- 511, 702,
- 515, 705,
- 520, 708,
- 548, 740,
- 554, 746,
- 555, 747,
- 559, 749,
- 562, 751,
- 593, 784,
- 597, 788,
- 604, 801,
- 613, 805,
- 615, 807,
- 632, 818,
- 662, 832,
- 669, 845,
- 676, 856,
- 699, 869,
- 731, 877,
- 741, 885,
- 744, 921,
- 745, 922,
- 782, 932,
- 785, 935,
- 790, 941,
- 796, 947,
- 799, 951,
- 814, 962,
- 815, 963,
- 816, 964,
- 820, 968,
- 828, 975,
- 829, 976,
- 831, 983,
- 868, 1021,
- 872, 1026,
- 889, 1040,
- 891, 1042,
- 893, 1045,
- 899, 1051,
- 924, 1069,
- 934, 1078,
- 942, 1087,
- 945, 1089,
- 948, 1091,
- 952, 1094,
- 966, 1141,
- 977, 1152,
- 985, 1159,
- 994, 1170,
- 998, 1172,
- 999, 1173,
- 1028, 1197,
- 1029, 1198,
- 1054, 1211,
- 1068, 1224,
- 1074, 1227,
- 1075, 1228,
- 1079, 1231,
- 1093, 1244,
- 1100, 1249,
- 1101, 1250,
- 1103, 1252,
- 1104, 1253,
- 1105, 1254,
- 1106, 1255,
- 1125, 1275,
- 1150, 1311,
- 1191, 1369,
- 1196, 1373,
- 1203, 1377,
- 1204, 1378,
- 1206, 1379,
- 1209, 1384,
- 1225, 1394,
- 1236, 1400,
- 1241, 1401,
- 1260, 1417,
- 1276, 1424,
- 1277, 1426,
- 1278, 1427,
- 1279, 1428,
- 1280, 1429,
- 1281, 1430,
- 1282, 1431,
- 1283, 1432,
- 1284, 1433,
- 1285, 1434,
- 1286, 1435,
- 1287, 1436,
- 1288, 1437,
+ 377, 585,
+ 378, 586,
+ 379, 587,
+ 380, 588,
+ 381, 589,
+ 382, 590,
+ 383, 591,
+ 384, 592,
+ 398, 606,
+ 402, 610,
+ 412, 217,
+ 445, 622,
+ 447, 625,
+ 454, 636,
+ 455, 637,
+ 456, 638,
+ 469, 645,
+ 470, 646,
+ 477, 674,
+ 489, 686,
+ 494, 689,
+ 507, 703,
+ 513, 706,
+ 519, 710,
+ 523, 713,
+ 528, 716,
+ 556, 748,
+ 562, 754,
+ 563, 755,
+ 567, 757,
+ 570, 759,
+ 601, 792,
+ 605, 796,
+ 612, 809,
+ 621, 813,
+ 623, 815,
+ 640, 826,
+ 670, 840,
+ 677, 853,
+ 684, 864,
+ 707, 877,
+ 739, 885,
+ 749, 893,
+ 752, 929,
+ 753, 930,
+ 790, 940,
+ 793, 943,
+ 798, 949,
+ 804, 955,
+ 807, 959,
+ 822, 970,
+ 823, 971,
+ 824, 972,
+ 828, 976,
+ 836, 983,
+ 837, 984,
+ 839, 991,
+ 876, 1029,
+ 880, 1034,
+ 897, 1048,
+ 899, 1050,
+ 901, 1053,
+ 907, 1059,
+ 932, 1077,
+ 942, 1086,
+ 950, 1095,
+ 953, 1097,
+ 956, 1099,
+ 960, 1102,
+ 974, 1151,
+ 985, 1162,
+ 993, 1169,
+ 1002, 1180,
+ 1006, 1182,
+ 1007, 1183,
+ 1036, 1207,
+ 1037, 1208,
+ 1062, 1221,
+ 1076, 1234,
+ 1082, 1237,
+ 1083, 1238,
+ 1087, 1241,
+ 1101, 1254,
+ 1108, 1259,
+ 1109, 1260,
+ 1111, 1262,
+ 1112, 1263,
+ 1113, 1264,
+ 1114, 1265,
+ 1135, 1287,
+ 1160, 1323,
+ 1201, 1381,
+ 1206, 1385,
+ 1213, 1389,
+ 1214, 1390,
+ 1216, 1391,
+ 1219, 1396,
+ 1235, 1406,
+ 1246, 1412,
+ 1251, 1413,
+ 1270, 1429,
+ 1288, 1436,
1289, 1438,
1290, 1439,
1291, 1440,
1296, 1445,
1297, 1446,
1298, 1447,
- 1308, 1456,
- 1309, 1457,
- 1312, 1459,
- 1334, 1482,
- 1359, 1493,
- 1360, 1494,
- 1375, 1499,
- 1376, 1500,
- 1402, 1522,
- 1408, 1525,
- 1410, 1526,
- 1411, 1527,
- 1419, 1533,
- 1425, 1537,
- 1455, 1570,
- 1460, 1572,
- 1466, 1576,
- 1469, 1580,
- 1474, 832,
- 1476, 832,
- 1477, 1589,
- 1488, 1601,
- 1497, 1610,
- 1503, 1616,
- 1518, 1626,
- 1520, 1627,
- 1530, 1633,
- 1562, 1639,
- 1574, 1647,
- 1577, 1648,
- 1582, 832,
- 1585, 832,
- 1588, 832,
- 1608, 1689,
- 1611, 1691,
- 1631, 1701,
- 1694, 1766,
- 1707, 1773,
- 1708, 1774,
- 1712, 1776,
- 1716, 1779,
- 1718, 1780,
- 1734, 1793,
- 1768, 1818,
- 1823, 1863,
- 1824, 1864,
- 1827, 1866,
- 1828, 1867,
- 1829, 1868,
- 1861, 1883,
- 1884, 1894,
- 1888, 1896
+ 1299, 1448,
+ 1300, 1449,
+ 1301, 1450,
+ 1302, 1451,
+ 1303, 1452,
+ 1304, 1453,
+ 1305, 1454,
+ 1306, 1455,
+ 1307, 1456,
+ 1308, 1457,
+ 1309, 1458,
+ 1310, 1459,
+ 1320, 1468,
+ 1321, 1469,
+ 1324, 1471,
+ 1346, 1494,
+ 1371, 1505,
+ 1372, 1506,
+ 1387, 1511,
+ 1388, 1512,
+ 1414, 1534,
+ 1420, 1537,
+ 1422, 1538,
+ 1423, 1539,
+ 1431, 1545,
+ 1437, 1549,
+ 1467, 1582,
+ 1472, 1584,
+ 1478, 1588,
+ 1481, 1592,
+ 1486, 840,
+ 1488, 840,
+ 1489, 1601,
+ 1500, 1613,
+ 1509, 1622,
+ 1515, 1628,
+ 1530, 1638,
+ 1532, 1639,
+ 1542, 1645,
+ 1574, 1651,
+ 1586, 1659,
+ 1589, 1660,
+ 1594, 840,
+ 1597, 840,
+ 1600, 840,
+ 1620, 1701,
+ 1623, 1703,
+ 1643, 1713,
+ 1706, 1778,
+ 1719, 1785,
+ 1720, 1786,
+ 1724, 1788,
+ 1728, 1791,
+ 1730, 1792,
+ 1746, 1805,
+ 1780, 1830,
+ 1835, 1875,
+ 1836, 1876,
+ 1839, 1878,
+ 1840, 1879,
+ 1841, 1880,
+ 1873, 1895,
+ 1896, 1906,
+ 1900, 1908
};
static int parser_goto_row119[] = {
4,
-1, 15,
- 22, 106,
- 25, 106,
- 165, 106
+ 22, 108,
+ 25, 108,
+ 169, 108
};
static int parser_goto_row120[] = {
1,
};
static int parser_goto_row121[] = {
4,
- -1, 982,
- 1587, 1662,
- 1652, 1724,
- 1663, 1744
+ -1, 990,
+ 1599, 1674,
+ 1664, 1736,
+ 1675, 1756
};
static int parser_goto_row122[] = {
13,
- -1, 442,
- 441, 624,
- 445, 627,
- 626, 813,
- 955, 624,
- 957, 627,
- 1099, 813,
- 1349, 624,
- 1357, 627,
- 1492, 813,
- 1677, 624,
- 1679, 627,
- 1756, 813
+ -1, 450,
+ 449, 632,
+ 453, 635,
+ 634, 821,
+ 963, 632,
+ 965, 635,
+ 1107, 821,
+ 1361, 632,
+ 1369, 635,
+ 1504, 821,
+ 1689, 632,
+ 1691, 635,
+ 1768, 821
};
static int parser_goto_row123[] = {
5,
- -1, 443,
- 805, 956,
- 1166, 1350,
- 1601, 1678,
- 1645, 1350
+ -1, 451,
+ 813, 964,
+ 1176, 1362,
+ 1613, 1690,
+ 1657, 1362
};
static int parser_goto_row124[] = {
1,
- -1, 1542
+ -1, 1554
};
static int parser_goto_row125[] = {
2,
- -1, 1125,
- 1883, 1893
+ -1, 1135,
+ 1895, 1905
};
static int parser_goto_row126[] = {
1,
- -1, 1126
+ -1, 1136
};
static int parser_goto_row127[] = {
6,
- -1, 1127,
- 1253, 1412,
- 1424, 1536,
- 1426, 1538,
- 1427, 1539,
- 1537, 1635
+ -1, 1137,
+ 1263, 1424,
+ 1436, 1548,
+ 1438, 1550,
+ 1439, 1551,
+ 1549, 1647
};
static int parser_goto_row128[] = {
1,
- -1, 1128
+ -1, 1138
};
static int parser_goto_row129[] = {
8,
- -1, 1129,
- 1430, 1544,
- 1431, 1545,
- 1432, 1546,
- 1433, 1547,
- 1434, 1548,
- 1435, 1549,
- 1436, 1550
+ -1, 1139,
+ 1442, 1556,
+ 1443, 1557,
+ 1444, 1558,
+ 1445, 1559,
+ 1446, 1560,
+ 1447, 1561,
+ 1448, 1562
};
static int parser_goto_row130[] = {
2,
- -1, 1130,
- 1429, 1543
+ -1, 1140,
+ 1441, 1555
};
static int parser_goto_row131[] = {
2,
- -1, 1131,
- 1437, 1551
+ -1, 1141,
+ 1449, 1563
};
static int parser_goto_row132[] = {
2,
- -1, 1132,
- 1438, 1552
+ -1, 1142,
+ 1450, 1564
};
static int parser_goto_row133[] = {
3,
- -1, 1133,
- 1439, 1553,
- 1440, 1554
+ -1, 1143,
+ 1451, 1565,
+ 1452, 1566
};
static int parser_goto_row134[] = {
3,
- -1, 1134,
- 1441, 1555,
- 1442, 1556
+ -1, 1144,
+ 1453, 1567,
+ 1454, 1568
};
static int parser_goto_row135[] = {
5,
- -1, 1135,
- 1443, 1557,
- 1444, 1558,
- 1445, 1559,
- 1446, 1560
+ -1, 1145,
+ 1455, 1569,
+ 1456, 1570,
+ 1457, 1571,
+ 1458, 1572
};
static int parser_goto_row136[] = {
5,
- -1, 1136,
- 1112, 1263,
- 1113, 1264,
- 1114, 1265,
- 1255, 1416
+ -1, 1146,
+ 1120, 1273,
+ 1121, 1274,
+ 1122, 1275,
+ 1265, 1428
};
static int parser_goto_row137[] = {
1,
- -1, 1137
+ -1, 1147
};
static int parser_goto_row138[] = {
2,
- -1, 1138,
- 1111, 1262
+ -1, 1148,
+ 1119, 1272
};
static int parser_goto_row139[] = {
1,
};
static int parser_goto_row140[] = {
1,
- -1, 1139
+ -1, 1149
};
static int parser_goto_row141[] = {
4,
- -1, 389,
- 281, 507,
- 346, 557,
- 509, 701
+ -1, 397,
+ 287, 515,
+ 354, 565,
+ 517, 709
};
static int parser_goto_row142[] = {
1,
};
static int parser_goto_row143[] = {
1,
- -1, 1351
+ -1, 1363
};
static int parser_goto_row144[] = {
4,
- -1, 141,
- 1166, 1352,
- 1610, 1690,
- 1645, 1352
+ -1, 145,
+ 1176, 1364,
+ 1622, 1702,
+ 1657, 1364
};
static int parser_goto_row145[] = {
1,
- -1, 142
+ -1, 146
};
static int parser_goto_row146[] = {
6,
- -1, 143,
- 280, 506,
- 519, 707,
- 521, 709,
- 522, 710,
- 708, 875
+ -1, 147,
+ 286, 514,
+ 527, 715,
+ 529, 717,
+ 530, 718,
+ 716, 883
};
static int parser_goto_row147[] = {
1,
- -1, 144
+ -1, 148
};
static int parser_goto_row148[] = {
8,
- -1, 145,
- 525, 713,
- 526, 714,
- 527, 715,
- 528, 716,
- 529, 717,
- 530, 718,
- 531, 719
+ -1, 149,
+ 533, 721,
+ 534, 722,
+ 535, 723,
+ 536, 724,
+ 537, 725,
+ 538, 726,
+ 539, 727
};
static int parser_goto_row149[] = {
2,
- -1, 146,
- 524, 712
+ -1, 150,
+ 532, 720
};
static int parser_goto_row150[] = {
2,
- -1, 147,
- 532, 720
+ -1, 151,
+ 540, 728
};
static int parser_goto_row151[] = {
2,
- -1, 148,
- 533, 721
+ -1, 152,
+ 541, 729
};
static int parser_goto_row152[] = {
3,
- -1, 149,
- 534, 722,
- 535, 723
+ -1, 153,
+ 542, 730,
+ 543, 731
};
static int parser_goto_row153[] = {
3,
- -1, 150,
- 536, 724,
- 537, 725
+ -1, 154,
+ 544, 732,
+ 545, 733
};
static int parser_goto_row154[] = {
5,
- -1, 151,
- 538, 726,
- 539, 727,
- 540, 728,
- 541, 729
+ -1, 155,
+ 546, 734,
+ 547, 735,
+ 548, 736,
+ 549, 737
};
static int parser_goto_row155[] = {
1,
- -1, 152
+ -1, 156
};
static int parser_goto_row156[] = {
1,
- -1, 153
+ -1, 157
};
static int parser_goto_row157[] = {
4,
- -1, 154,
- 125, 289,
- 1166, 1353,
- 1645, 1353
+ -1, 158,
+ 127, 295,
+ 1176, 1365,
+ 1657, 1365
};
static int parser_goto_row158[] = {
1,
};
static int parser_goto_row159[] = {
2,
- -1, 155,
- 1085, 1239
+ -1, 159,
+ 1093, 1249
};
static int parser_goto_row160[] = {
1,
- -1, 595
+ -1, 603
};
static int parser_goto_row161[] = {
7,
- -1, 596,
- 592, 783,
- 1080, 1232,
- 1230, 1397,
- 1395, 1519,
- 1414, 1529,
- 1528, 1632
+ -1, 604,
+ 600, 791,
+ 1088, 1242,
+ 1240, 1409,
+ 1407, 1531,
+ 1426, 1541,
+ 1540, 1644
};
static int parser_goto_row162[] = {
1,
- -1, 787
+ -1, 795
};
static int parser_goto_row163[] = {
1,
};
static int parser_goto_row164[] = {
2,
- -1, 1354,
- 1645, 1715
+ -1, 1366,
+ 1657, 1727
};
static int parser_goto_row165[] = {
1,
- -1, 1355
+ -1, 1367
};
static int parser_goto_row166[] = {
2,
- -1, 1415,
- 1417, 1532
+ -1, 1427,
+ 1429, 1544
};
static int parser_goto_row167[] = {
1,
};
static int parser_goto_row184[] = {
8,
- -1, 1037,
- 892, 1043,
- 1208, 1383,
- 1380, 1504,
- 1502, 1614,
- 1507, 1617,
- 1692, 1765,
- 1817, 1859
+ -1, 1045,
+ 900, 1051,
+ 1218, 1395,
+ 1392, 1516,
+ 1514, 1626,
+ 1519, 1629,
+ 1704, 1777,
+ 1829, 1871
};
static int parser_goto_row185[] = {
3,
- -1, 1038,
- 742, 910,
- 1501, 1613
+ -1, 1046,
+ 750, 918,
+ 1513, 1625
};
static int parser_goto_row186[] = {
1,
- -1, 911
+ -1, 919
};
static int parser_goto_row187[] = {
1,
- -1, 912
+ -1, 920
};
static int parser_goto_row188[] = {
1,
- -1, 913
+ -1, 921
};
static int parser_goto_row189[] = {
1,
- -1, 914
+ -1, 922
};
static int parser_goto_row190[] = {
1,
- -1, 915
+ -1, 923
};
static int parser_goto_row191[] = {
1,
- -1, 916
+ -1, 924
};
static int parser_goto_row192[] = {
1,
- -1, 917
+ -1, 925
};
static int parser_goto_row193[] = {
1,
};
static int parser_goto_row194[] = {
10,
- -1, 161,
- 37, 168,
- 743, 920,
- 798, 950,
- 888, 1039,
- 892, 1044,
- 1393, 1517,
- 1502, 1615,
- 1507, 1618,
- 1817, 1860
+ -1, 165,
+ 37, 172,
+ 751, 928,
+ 806, 958,
+ 896, 1047,
+ 900, 1052,
+ 1405, 1529,
+ 1514, 1627,
+ 1519, 1630,
+ 1829, 1872
};
static int parser_goto_row195[] = {
1,
};
static int parser_goto_row196[] = {
1,
- -1, 444
+ -1, 452
};
static int parser_goto_row197[] = {
1,
- -1, 1356
+ -1, 1368
};
static int parser_goto_row198[] = {
1,
};
static int parser_goto_row200[] = {
1,
- -1, 1166
+ -1, 1176
};
static int parser_goto_row201[] = {
1,
4,
-1, 19,
5, 29,
- 18, 94,
- 28, 111
+ 18, 96,
+ 28, 113
};
static int parser_goto_row204[] = {
8,
-1, 20,
5, 30,
- 18, 95,
- 19, 99,
- 28, 112,
- 29, 114,
- 94, 265,
- 111, 274
+ 18, 97,
+ 19, 101,
+ 28, 114,
+ 29, 116,
+ 96, 271,
+ 113, 280
};
static int parser_goto_row205[] = {
1,
- -1, 1471
+ -1, 1483
};
static int parser_goto_row206[] = {
1,
- -1, 994
+ -1, 1002
};
static int parser_goto_row207[] = {
4,
- -1, 1304,
- 1154, 1319,
- 1727, 1785,
- 1791, 1836
+ -1, 1316,
+ 1164, 1331,
+ 1739, 1797,
+ 1803, 1848
};
static int parser_goto_row208[] = {
1,
- -1, 1312
+ -1, 1324
};
static int parser_goto_row209[] = {
1,
- -1, 1462
+ -1, 1474
};
static int parser_goto_row210[] = {
1,
- -1, 1077
+ -1, 1085
};
static int parser_goto_row211[] = {
3,
- -1, 243,
- 331, 546,
- 1060, 1218
+ -1, 249,
+ 339, 554,
+ 1068, 1228
};
static int parser_goto_row212[] = {
1,
- -1, 618
+ -1, 626
};
static int parser_goto_row213[] = {
1,
- -1, 634
+ -1, 642
};
static int parser_goto_row214[] = {
1,
- -1, 252
+ -1, 258
};
static int parser_goto_row215[] = {
1,
- -1, 944
+ -1, 952
};
static int parser_goto_row216[] = {
2,
- -1, 1404,
- 1355, 1490
+ -1, 1416,
+ 1367, 1502
};
static int parser_goto_row217[] = {
1,
- -1, 874
+ -1, 882
};
static int parser_goto_row218[] = {
170,
- -1, 196,
- 13, 83,
- 27, 83,
- 31, 156,
- 33, 83,
- 37, 83,
- 54, 156,
- 98, 83,
- 125, 156,
- 160, 83,
- 212, 445,
- 242, 83,
- 254, 156,
- 256, 156,
- 257, 156,
- 258, 156,
- 259, 156,
- 280, 156,
- 386, 83,
- 467, 664,
- 472, 83,
- 474, 673,
- 497, 156,
- 498, 156,
- 519, 156,
- 521, 156,
- 522, 156,
- 524, 156,
- 525, 156,
- 526, 156,
- 527, 156,
- 528, 156,
- 529, 156,
- 530, 156,
- 531, 156,
- 532, 156,
- 533, 156,
- 534, 156,
- 535, 156,
- 536, 156,
- 537, 156,
- 538, 156,
- 539, 156,
- 540, 156,
- 541, 156,
- 542, 735,
- 545, 83,
- 584, 777,
- 588, 83,
- 591, 83,
- 637, 823,
- 638, 823,
- 666, 841,
- 668, 156,
- 670, 156,
- 702, 735,
- 708, 156,
- 738, 83,
- 742, 918,
- 743, 83,
- 749, 777,
- 788, 939,
- 798, 83,
- 805, 957,
- 807, 445,
- 851, 156,
- 852, 156,
- 853, 156,
- 854, 156,
- 869, 1024,
- 887, 156,
- 888, 918,
- 890, 83,
- 892, 918,
- 901, 156,
- 909, 83,
- 964, 1140,
- 968, 1143,
- 979, 83,
- 1016, 156,
- 1017, 156,
- 1036, 83,
- 1055, 156,
- 1056, 156,
- 1057, 156,
- 1058, 83,
- 1062, 83,
- 1063, 156,
- 1064, 156,
- 1089, 445,
- 1111, 1140,
- 1112, 1140,
- 1113, 1140,
- 1114, 1140,
- 1152, 664,
- 1156, 83,
- 1166, 1357,
- 1208, 918,
- 1211, 1389,
- 1216, 83,
- 1222, 156,
- 1223, 156,
- 1253, 1140,
- 1255, 1140,
- 1380, 918,
- 1382, 83,
- 1386, 156,
- 1387, 156,
- 1393, 83,
- 1400, 445,
- 1424, 1140,
- 1426, 1140,
- 1427, 1140,
- 1429, 1140,
- 1430, 1140,
- 1431, 1140,
- 1432, 1140,
- 1433, 1140,
- 1434, 1140,
- 1435, 1140,
- 1436, 1140,
- 1437, 1140,
- 1438, 1140,
- 1439, 1140,
- 1440, 1140,
- 1441, 1140,
- 1442, 1140,
- 1443, 1140,
- 1444, 1140,
- 1445, 1140,
- 1446, 1140,
- 1447, 1566,
- 1463, 664,
- 1472, 664,
- 1474, 664,
- 1476, 664,
- 1482, 445,
- 1501, 918,
- 1502, 918,
- 1507, 918,
- 1511, 156,
- 1512, 156,
- 1513, 156,
- 1514, 156,
- 1522, 445,
- 1533, 1566,
- 1537, 1140,
- 1572, 664,
- 1601, 1679,
- 1610, 156,
- 1623, 156,
- 1624, 156,
- 1633, 1704,
- 1645, 1357,
- 1655, 83,
- 1659, 83,
- 1692, 918,
- 1721, 83,
- 1729, 83,
- 1730, 83,
- 1733, 83,
- 1738, 83,
- 1741, 83,
- 1776, 445,
- 1782, 83,
- 1789, 83,
- 1794, 83,
- 1799, 83,
- 1817, 918,
- 1883, 1140
+ -1, 200,
+ 13, 85,
+ 27, 85,
+ 31, 160,
+ 33, 85,
+ 37, 85,
+ 54, 160,
+ 100, 85,
+ 127, 160,
+ 164, 85,
+ 216, 453,
+ 248, 85,
+ 260, 160,
+ 262, 160,
+ 263, 160,
+ 264, 160,
+ 265, 160,
+ 286, 160,
+ 394, 85,
+ 475, 672,
+ 480, 85,
+ 482, 681,
+ 505, 160,
+ 506, 160,
+ 527, 160,
+ 529, 160,
+ 530, 160,
+ 532, 160,
+ 533, 160,
+ 534, 160,
+ 535, 160,
+ 536, 160,
+ 537, 160,
+ 538, 160,
+ 539, 160,
+ 540, 160,
+ 541, 160,
+ 542, 160,
+ 543, 160,
+ 544, 160,
+ 545, 160,
+ 546, 160,
+ 547, 160,
+ 548, 160,
+ 549, 160,
+ 550, 743,
+ 553, 85,
+ 592, 785,
+ 596, 85,
+ 599, 85,
+ 645, 831,
+ 646, 831,
+ 674, 849,
+ 676, 160,
+ 678, 160,
+ 710, 743,
+ 716, 160,
+ 746, 85,
+ 750, 926,
+ 751, 85,
+ 757, 785,
+ 796, 947,
+ 806, 85,
+ 813, 965,
+ 815, 453,
+ 859, 160,
+ 860, 160,
+ 861, 160,
+ 862, 160,
+ 877, 1032,
+ 895, 160,
+ 896, 926,
+ 898, 85,
+ 900, 926,
+ 909, 160,
+ 917, 85,
+ 972, 1150,
+ 976, 1153,
+ 987, 85,
+ 1024, 160,
+ 1025, 160,
+ 1044, 85,
+ 1063, 160,
+ 1064, 160,
+ 1065, 160,
+ 1066, 85,
+ 1070, 85,
+ 1071, 160,
+ 1072, 160,
+ 1097, 453,
+ 1119, 1150,
+ 1120, 1150,
+ 1121, 1150,
+ 1122, 1150,
+ 1162, 672,
+ 1166, 85,
+ 1176, 1369,
+ 1218, 926,
+ 1221, 1401,
+ 1226, 85,
+ 1232, 160,
+ 1233, 160,
+ 1263, 1150,
+ 1265, 1150,
+ 1392, 926,
+ 1394, 85,
+ 1398, 160,
+ 1399, 160,
+ 1405, 85,
+ 1412, 453,
+ 1436, 1150,
+ 1438, 1150,
+ 1439, 1150,
+ 1441, 1150,
+ 1442, 1150,
+ 1443, 1150,
+ 1444, 1150,
+ 1445, 1150,
+ 1446, 1150,
+ 1447, 1150,
+ 1448, 1150,
+ 1449, 1150,
+ 1450, 1150,
+ 1451, 1150,
+ 1452, 1150,
+ 1453, 1150,
+ 1454, 1150,
+ 1455, 1150,
+ 1456, 1150,
+ 1457, 1150,
+ 1458, 1150,
+ 1459, 1578,
+ 1475, 672,
+ 1484, 672,
+ 1486, 672,
+ 1488, 672,
+ 1494, 453,
+ 1513, 926,
+ 1514, 926,
+ 1519, 926,
+ 1523, 160,
+ 1524, 160,
+ 1525, 160,
+ 1526, 160,
+ 1534, 453,
+ 1545, 1578,
+ 1549, 1150,
+ 1584, 672,
+ 1613, 1691,
+ 1622, 160,
+ 1635, 160,
+ 1636, 160,
+ 1645, 1716,
+ 1657, 1369,
+ 1667, 85,
+ 1671, 85,
+ 1704, 926,
+ 1733, 85,
+ 1741, 85,
+ 1742, 85,
+ 1745, 85,
+ 1750, 85,
+ 1753, 85,
+ 1788, 453,
+ 1794, 85,
+ 1801, 85,
+ 1806, 85,
+ 1811, 85,
+ 1829, 926,
+ 1895, 1150
};
static int parser_goto_row219[] = {
78,
- -1, 164,
+ -1, 168,
0, 21,
3, 24,
5, 21,
18, 21,
19, 21,
20, 24,
- 22, 107,
- 25, 108,
+ 22, 109,
+ 25, 110,
28, 21,
29, 21,
30, 24,
33, 24,
37, 24,
- 64, 24,
- 94, 21,
- 95, 24,
- 99, 24,
- 104, 24,
- 105, 24,
- 111, 21,
- 112, 24,
+ 66, 24,
+ 96, 21,
+ 97, 24,
+ 101, 24,
+ 106, 24,
+ 107, 24,
+ 113, 21,
114, 24,
- 165, 337,
- 243, 24,
- 265, 24,
+ 116, 24,
+ 169, 345,
+ 249, 24,
271, 24,
- 274, 24,
- 331, 24,
- 386, 24,
- 546, 24,
- 588, 24,
- 742, 24,
- 743, 24,
- 798, 24,
- 839, 24,
- 888, 24,
- 890, 24,
- 892, 24,
- 979, 24,
- 990, 24,
- 994, 21,
- 1058, 24,
- 1060, 24,
- 1062, 24,
- 1145, 24,
- 1154, 24,
- 1156, 24,
- 1208, 24,
- 1216, 24,
+ 277, 24,
+ 280, 24,
+ 339, 24,
+ 394, 24,
+ 554, 24,
+ 596, 24,
+ 750, 24,
+ 751, 24,
+ 806, 24,
+ 847, 24,
+ 896, 24,
+ 898, 24,
+ 900, 24,
+ 987, 24,
+ 998, 24,
+ 1002, 21,
+ 1066, 24,
+ 1068, 24,
+ 1070, 24,
+ 1155, 24,
+ 1164, 24,
+ 1166, 24,
1218, 24,
- 1304, 24,
- 1319, 24,
- 1380, 24,
- 1393, 24,
- 1468, 24,
- 1501, 24,
- 1502, 24,
- 1507, 24,
- 1579, 24,
- 1655, 24,
- 1659, 24,
- 1692, 24,
- 1721, 24,
- 1727, 24,
- 1729, 24,
- 1730, 24,
+ 1226, 24,
+ 1228, 24,
+ 1316, 24,
+ 1331, 24,
+ 1392, 24,
+ 1405, 24,
+ 1480, 24,
+ 1513, 24,
+ 1514, 24,
+ 1519, 24,
+ 1591, 24,
+ 1667, 24,
+ 1671, 24,
+ 1704, 24,
1733, 24,
- 1738, 24,
+ 1739, 24,
1741, 24,
- 1782, 24,
- 1785, 24,
- 1789, 24,
- 1791, 24,
+ 1742, 24,
+ 1745, 24,
+ 1750, 24,
+ 1753, 24,
1794, 24,
- 1799, 24,
- 1817, 24,
- 1836, 24
+ 1797, 24,
+ 1801, 24,
+ 1803, 24,
+ 1806, 24,
+ 1811, 24,
+ 1829, 24,
+ 1848, 24
};
static int parser_goto_row220[] = {
75,
- -1, 165,
+ -1, 169,
0, 22,
3, 25,
5, 22,
30, 25,
33, 25,
37, 25,
- 64, 25,
- 94, 22,
- 95, 25,
- 99, 25,
- 104, 25,
- 105, 25,
- 111, 22,
- 112, 25,
+ 66, 25,
+ 96, 22,
+ 97, 25,
+ 101, 25,
+ 106, 25,
+ 107, 25,
+ 113, 22,
114, 25,
- 243, 25,
- 265, 25,
+ 116, 25,
+ 249, 25,
271, 25,
- 274, 25,
- 331, 25,
- 386, 25,
- 546, 25,
- 588, 25,
- 742, 25,
- 743, 25,
- 798, 25,
- 839, 25,
- 888, 25,
- 890, 25,
- 892, 25,
- 979, 25,
- 990, 25,
- 994, 22,
- 1058, 25,
- 1060, 25,
- 1062, 25,
- 1145, 25,
- 1154, 25,
- 1156, 25,
- 1208, 25,
- 1216, 25,
+ 277, 25,
+ 280, 25,
+ 339, 25,
+ 394, 25,
+ 554, 25,
+ 596, 25,
+ 750, 25,
+ 751, 25,
+ 806, 25,
+ 847, 25,
+ 896, 25,
+ 898, 25,
+ 900, 25,
+ 987, 25,
+ 998, 25,
+ 1002, 22,
+ 1066, 25,
+ 1068, 25,
+ 1070, 25,
+ 1155, 25,
+ 1164, 25,
+ 1166, 25,
1218, 25,
- 1304, 25,
- 1319, 25,
- 1380, 25,
- 1393, 25,
- 1468, 25,
- 1501, 25,
- 1502, 25,
- 1507, 25,
- 1579, 25,
- 1655, 25,
- 1659, 25,
- 1692, 25,
- 1721, 25,
- 1727, 25,
- 1729, 25,
- 1730, 25,
+ 1226, 25,
+ 1228, 25,
+ 1316, 25,
+ 1331, 25,
+ 1392, 25,
+ 1405, 25,
+ 1480, 25,
+ 1513, 25,
+ 1514, 25,
+ 1519, 25,
+ 1591, 25,
+ 1667, 25,
+ 1671, 25,
+ 1704, 25,
1733, 25,
- 1738, 25,
+ 1739, 25,
1741, 25,
- 1782, 25,
- 1785, 25,
- 1789, 25,
- 1791, 25,
+ 1742, 25,
+ 1745, 25,
+ 1750, 25,
+ 1753, 25,
1794, 25,
- 1799, 25,
- 1817, 25,
- 1836, 25
+ 1797, 25,
+ 1801, 25,
+ 1803, 25,
+ 1806, 25,
+ 1811, 25,
+ 1829, 25,
+ 1848, 25
};
const int* const parser_goto_table[] = {
assert sup isa MClassType
- # `sub` and `sup` can be discovered inside a Generic type during the subtyping test
- if not sup.mclass.loaded then create_class(sup.mclass)
- if not sub.mclass.loaded then create_class(sub.mclass)
+ # and `sup` can be discovered inside a Generic type during the subtyping test
+ if not sub.mclass.loaded then load_class(sub.mclass)
+
+ # If the target of the test is not-loaded yet, the subtyping-test will be false
+ if not sup.mclass.abstract_loaded then return false
# For now, always use perfect hashing for subtyping test
var super_id = sup.mclass.vtable.id
# Redef init_instance to simulate the loading of a class
redef fun init_instance(recv: Instance)
do
- if not recv.mtype.as(MClassType).mclass.loaded then create_class(recv.mtype.as(MClassType).mclass)
+ if not recv.mtype.as(MClassType).mclass.loaded then load_class(recv.mtype.as(MClassType).mclass)
recv.vtable = recv.mtype.as(MClassType).mclass.vtable
# Associate a `PrimitiveInstance` to its `VTable`
redef fun init_instance_primitive(recv: Instance)
do
- if not recv.mtype.as(MClassType).mclass.loaded then create_class(recv.mtype.as(MClassType).mclass)
+ if not recv.mtype.as(MClassType).mclass.loaded then load_class(recv.mtype.as(MClassType).mclass)
recv.vtable = recv.mtype.as(MClassType).mclass.vtable
end
return attributes;
`}
- # Creates the runtime structures for this class
- fun create_class(mclass: MClass) do mclass.make_vt(self)
+ # Load the class and create its runtime structures, this loading is explicit
+ fun load_class(mclass: MClass)
+ do
+ if mclass.loaded then return
+
+ # Recursively load superclasses
+ for parent in mclass.in_hierarchy(mainmodule).direct_greaters do load_class_indirect(parent)
+
+ if mclass.abstract_loaded then
+ mclass.allocate_vtable(self)
+ else
+ mclass.make_vt(self, true)
+ end
+ end
+
+ # This method is called to handle an implicitly loaded class,
+ # i.e. a superclass of an explicitly loaded class
+ # A class loaded implicitly will not be fully allocated
+ fun load_class_indirect(mclass: MClass)
+ do
+ # It the class was already implicitly loaded
+ if mclass.abstract_loaded then return
+
+ for parent in mclass.in_hierarchy(mainmodule).direct_greaters do load_class_indirect(parent)
+
+ mclass.make_vt(self, false)
+ end
# Execute `mproperty` for a `args` (where `args[0]` is the receiver).
redef fun send(mproperty: MMethod, args: Array[Instance]): nullable Instance
# returns the most specific local method in the class corresponding to `vtable`
private fun method_dispatch(mproperty: MMethod, vtable: VTable, recv: Instance): MMethodDef
do
- if mproperty.intro_mclassdef.mclass.positions_methods[recv.mtype.as(MClassType).mclass] != -1 then
- return method_dispatch_sst(vtable.internal_vtable, mproperty.absolute_offset)
+ var position = recv.mtype.as(MClassType).mclass.get_position_methods(mproperty.intro_mclassdef.mclass)
+ if position > 0 then
+ return method_dispatch_sst(vtable.internal_vtable, mproperty.offset + position)
else
return method_dispatch_ph(vtable.internal_vtable, vtable.mask,
mproperty.intro_mclassdef.mclass.vtable.id, mproperty.offset)
assert recv isa MutableInstance
var i: Instance
-
- if mproperty.intro_mclassdef.mclass.positions_attributes[recv.mtype.as(MClassType).mclass] != -1 then
+ var position = recv.mtype.as(MClassType).mclass.get_position_attributes(mproperty.intro_mclassdef.mclass)
+ if position > 0 then
# if this attribute class has an unique position for this receiver, then use direct access
- i = read_attribute_sst(recv.internal_attributes, mproperty.absolute_offset)
+ i = read_attribute_sst(recv.internal_attributes, position + mproperty.offset)
else
# Otherwise, read the attribute value with perfect hashing
var id = mproperty.intro_mclassdef.mclass.vtable.id
assert recv isa MutableInstance
# Replace the old value of mproperty in recv
- if mproperty.intro_mclassdef.mclass.positions_attributes[recv.mtype.as(MClassType).mclass] != -1 then
+ var position = recv.mtype.as(MClassType).mclass.get_position_attributes(mproperty.intro_mclassdef.mclass)
+ if position > -1 then
# if this attribute class has an unique position for this receiver, then use direct access
- write_attribute_sst(recv.internal_attributes, mproperty.absolute_offset, value)
+ write_attribute_sst(recv.internal_attributes, position + mproperty.offset, value)
else
# Otherwise, use perfect hashing to replace the old value
var id = mproperty.intro_mclassdef.mclass.vtable.id
# True when the class is effectively loaded by the vm, false otherwise
var loaded: Bool = false
+ # Indicate this class was partially loaded (it only has its identifier allocated)
+ var abstract_loaded: Bool = false
+
# Color for Cohen subtyping test : the absolute position of the id
# of this class in virtual tables
var color: Int
- # For each loaded subclass, keep the position of the group of attributes
- # introduced by self class in the object
+ # For superclasses which have a non-invariant position, keep their position in attribute table
var positions_attributes: HashMap[MClass, Int] = new HashMap[MClass, Int]
- # For each loaded subclass, keep the position of the group of methods
- # introduced by self class in the vtable
+ # For superclasses which have a non-invariant position, keep their position in virtual table
var positions_methods: HashMap[MClass, Int] = new HashMap[MClass, Int]
+ # The position of the class' block in virtual table,
+ # the position is set to -1 when the invariant position is no longer satisfied
+ var position_attributes: Int
+
+ # The position of the class' block in attribute table
+ # the position is set to -1 when the invariant position is no longer satisfied
+ var position_methods: Int
+
+ # The chosen prefix for this class.
+ # The prefix is the direct superclass which has the most properties,
+ # this class will stay at its usual position in virtual table and attribute table
+ var prefix: nullable MClass
+
+ # The linear extension of all superclasses with the prefix rule
+ var ordering: Array[MClass]
+
# The `MAttribute` this class introduced
var intro_mattributes = new Array[MAttribute]
var mmethods = new Array[MMethod]
# Allocates a VTable for this class and gives it an id
- private fun make_vt(v: VirtualMachine)
+ # * `vm` The currently executed VirtualMachine
+ # * `explicit` Indicate if this class was directly instantiated (i.e. not indirectly loaded)
+ private fun make_vt(vm: VirtualMachine, explicit: Bool)
do
- if loaded then return
+ # `ordering` contains the order of superclasses for virtual tables
+ ordering = superclasses_ordering(vm)
+ ordering.remove(self)
- # `superclasses` contains the order of superclasses for virtual tables
- var superclasses = superclasses_ordering(v)
- superclasses.remove(self)
-
- # Make_vt for super-classes
var ids = new Array[Int]
var nb_methods = new Array[Int]
var nb_attributes = new Array[Int]
# and the second and third are respectively class id and delta
var offset_methods = 3
- # The previous element in `superclasses`
- var previous_parent: nullable MClass = null
- if superclasses.length > 0 then previous_parent = superclasses[0]
- for parent in superclasses do
- if not parent.loaded then parent.make_vt(v)
+ var parent
+ var prefix_index = ordering.index_of(prefix.as(not null))
+ for i in [0..ordering.length[ do
+ parent = ordering[i]
# Get the number of introduced methods and attributes for this class
var methods = parent.intro_mmethods.length
nb_methods.push(methods)
nb_attributes.push(attributes)
- # Update `positions_attributes` and `positions_methods` in `parent`.
- # If the position is invariant for this parent, store this position
- # else store a special value (-1)
- var pos_attr = -1
- var pos_meth = -1
-
- if previous_parent.as(not null).positions_attributes[parent] == offset_attributes then pos_attr = offset_attributes
- if previous_parent.as(not null).positions_methods[parent] == offset_methods then pos_meth = offset_methods
-
- parent.update_positions(pos_attr, pos_meth, self)
+ # If the class is in the suffix part of the order
+ if i > prefix_index then
+ moved_class_attributes(vm, ordering[i], offset_attributes)
+ moved_class_methods(vm, ordering[i], offset_methods)
+ end
offset_attributes += attributes
offset_methods += methods
offset_methods += 2 # Because each block starts with an id and the delta
end
- # When all super-classes have their identifiers and vtables, allocate current one
- allocate_vtable(v, ids, nb_methods, nb_attributes, offset_attributes, offset_methods)
- loaded = true
+ # Update the positions of the class
+ update_positions(offset_attributes, offset_methods)
- # Set the absolute position of the identifier of this class in the virtual table
- color = offset_methods - 2
+ ordering.add(self)
- # The virtual table now needs to be filled with pointer to methods
- superclasses.add(self)
- for cl in superclasses do
- fill_vtable(v, vtable.as(not null), cl)
+ # Compute the identifier with Perfect Hashing
+ compute_identifier(vm, ids, offset_methods)
+
+ # Update caches and offsets of methods and attributes for this class
+ # If the loading was explicit, the virtual table will be allocated and filled
+ set_offsets(vm, explicit)
+
+ if not explicit then
+ # Just init the C-pointer to NULL to avoid errors
+ vtable.internal_vtable = vm.memory_manager.null_ptr
end
end
- # Allocate a single vtable
- # * `ids : Array of superclasses identifiers
- # * `nb_methods : Array which contain the number of introduced methods for each class in ids
- # * `nb_attributes : Array which contain the number of introduced attributes for each class in ids
- # * `offset_attributes : Offset from the beginning of the table of the group of attributes
+ # Allocate a unique identifier to the class with perfect hashing
+ # * `vm` The currently executed VirtualMachine
+ # * `ids` Array of superclasses identifiers
# * `offset_methods : Offset from the beginning of the table of the group of methods
- private fun allocate_vtable(v: VirtualMachine, ids: Array[Int], nb_methods: Array[Int], nb_attributes: Array[Int],
- offset_attributes: Int, offset_methods: Int)
+ private fun compute_identifier(vm: VirtualMachine, ids: Array[Int], offset_methods: Int)
do
vtable = new VTable
var idc = new Array[Int]
- vtable.mask = v.ph.pnand(ids, 1, idc) - 1
+ # Give an identifier to the class and put it inside the virtual table
+ vtable.mask = vm.ph.pnand(ids, 1, idc) - 1
vtable.id = idc[0]
vtable.classname = name
- # Add current id to Array of super-ids
- var ids_total = new Array[Int]
- ids_total.add_all(ids)
- ids_total.push(vtable.id)
+ # Set the color for subtyping tests in SST of this class
+ color = offset_methods - 2
- var nb_methods_total = new Array[Int]
- var nb_attributes_total = new Array[Int]
+ # Indicate the class has its identifier computed
+ abstract_loaded = true
+ end
- var self_methods = 0
- var nb_introduced_attributes = 0
+ # Update the positions of this class
+ # * `offset_attributes` The offset of the block of attributes of this class
+ # * `offset_methods` The offset of the block of methods of this class
+ private fun update_positions(offset_attributes: Int, offset_methods: Int)
+ do
+ # Recopy the position tables of the prefix in `self`
+ for key, value in prefix.positions_methods do
+ positions_methods[key] = value
+ end
+ for key, value in prefix.positions_attributes do
+ positions_attributes[key] = value
+ end
+
+ # Save the offsets of self class
+ position_attributes = offset_attributes
+ position_methods = offset_methods
+ end
+
+ # Set the offsets for the properties introduced by `self` class
+ # * `vm` The currently executed VirtualMachine
+ # * `explicit` Indicate if this class was explicitly loaded
+ private fun set_offsets(vm: VirtualMachine, explicit: Bool)
+ do
# Fixing offsets for self attributes and methods
var relative_offset_attr = 0
var relative_offset_meth = 0
for p in classdef.intro_mproperties do
# Collect properties and fixing offsets
if p isa MMethod then
- self_methods += 1
p.offset = relative_offset_meth
- p.absolute_offset = offset_methods + relative_offset_meth
relative_offset_meth += 1
intro_mmethods.add(p)
end
if p isa MAttribute then
- nb_introduced_attributes += 1
p.offset = relative_offset_attr
- p.absolute_offset = offset_attributes + relative_offset_attr
relative_offset_attr += 1
intro_mattributes.add(p)
mattributes.add_all(intro_mattributes)
mmethods.add_all(intro_mmethods)
- nb_methods_total.add_all(nb_methods)
- nb_methods_total.push(self_methods)
+ if explicit then allocate_vtable(vm)
+ end
- nb_attributes_total.add_all(nb_attributes)
- nb_attributes_total.push(nb_introduced_attributes)
+ # Allocate a single vtable
+ # * `vm` The currently executed VirtualMachine
+ private fun allocate_vtable(vm: VirtualMachine)
+ do
+ var ids = new Array[Int]
+ var nb_methods_total = new Array[Int]
+ var nb_attributes_total = new Array[Int]
- # Save the offsets of self class
- update_positions(offset_attributes, offset_methods, self)
+ for cl in ordering do
+ ids.add(cl.vtable.id)
+ nb_methods_total.add(cl.intro_mmethods.length)
+ nb_attributes_total.add(cl.intro_mattributes.length)
+ end
- # Since we have the number of attributes for each class, calculate the delta
+ # Calculate the delta to prepare object structure
var deltas = calculate_delta(nb_attributes_total)
- vtable.internal_vtable = v.memory_manager.init_vtable(ids_total, nb_methods_total, deltas, vtable.mask)
+ vtable.internal_vtable = vm.memory_manager.init_vtable(ids, nb_methods_total, deltas, vtable.mask)
+
+ # The virtual table now needs to be filled with pointer to methods
+ for cl in ordering do
+ fill_vtable(vm, vtable.as(not null), cl)
+ end
+
+ loaded = true
end
- # Fill the vtable with methods of `self` class
- # * `v` : Current instance of the VirtualMachine
- # * `table` : the table of self class, will be filled with its methods
- private fun fill_vtable(v:VirtualMachine, table: VTable, cl: MClass)
+ # Fill the vtable with local methods for `self` class
+ # * `vm` Current instance of the VirtualMachine
+ # * `table` the table of self class, will be filled with its methods
+ # * `cl` The class which introduced the methods
+ private fun fill_vtable(vm: VirtualMachine, table: VTable, cl: MClass)
do
var methods = new Array[MMethodDef]
for m in cl.intro_mmethods do
# `propdef` is the most specific implementation for this MMethod
- var propdef = m.lookup_first_definition(v.mainmodule, self.intro.bound_mtype)
+ var propdef = m.lookup_first_definition(vm.mainmodule, self.intro.bound_mtype)
methods.push(propdef)
end
# Call a method in C to put propdefs of self methods in the vtables
- v.memory_manager.put_methods(vtable.internal_vtable, vtable.mask, cl.vtable.id, methods)
+ vm.memory_manager.put_methods(vtable.internal_vtable, vtable.mask, cl.vtable.id, methods)
end
# Computes delta for each class
return ordering
else
# There is no super-class, self is Object
+ prefix = self
return superclasses
end
end
end
if prefix != null then
+ if self.prefix == null then self.prefix = prefix
+
# Add the prefix class ordering at the beginning of our sequence
var prefix_res = new Array[MClass]
prefix_res = prefix.dfs(v, prefix_res)
res.push(self)
else
if direct_parents.length > 0 then
+ if prefix == null then prefix = direct_parents.first
+
res = direct_parents.first.dfs(v, res)
end
end
return res
end
- # Update positions of the class `cl`
- # * `attributes_offset`: absolute offset of introduced attributes
- # * `methods_offset`: absolute offset of introduced methods
- private fun update_positions(attributes_offsets: Int, methods_offset:Int, cl: MClass)
+ # This method is called when `current_class` class is moved in virtual table of `self`
+ # *`vm` Running instance of the virtual machine
+ # *`current_class` The class which was moved in `self` structures
+ # *`offset` The offset of block of methods of `current_class` in `self`
+ fun moved_class_methods(vm: VirtualMachine, current_class: MClass, offset: Int)
do
- positions_attributes[cl] = attributes_offsets
- positions_methods[cl] = methods_offset
+ # `current_class` was moved in `self` method table
+ if current_class.position_methods > 0 then
+ # The invariant position is no longer satisfied
+ current_class.positions_methods[current_class] = current_class.position_methods
+ current_class.position_methods = - current_class.position_methods
+ else
+ # The class has already several positions and an update is needed
+ current_class.positions_methods[current_class] = -current_class.positions_methods[current_class]
+
+ for sub in ordering do
+ if sub == current_class then continue
+
+ var super_id = current_class.vtable.id
+ var mask = sub.vtable.mask
+ vm.load_class(sub)
+
+ if vm.inter_is_subtype_ph(super_id, mask, sub.vtable.internal_vtable) then
+ if not sub.positions_methods.has_key(current_class) then
+ sub.positions_methods[current_class] = current_class.position_methods
+ else
+ var old_position = sub.positions_methods[current_class]
+ if old_position > 0 then
+ # Indicate this class can not used anymore single inheritance implementation
+ sub.positions_methods[current_class] = - old_position
+ end
+ end
+ end
+ end
+ end
+
+ # Save the position of `current_class` in `self`
+ positions_methods[current_class] = offset
end
+
+ # This method is called when `current_class` class is moved in attribute table of `self`
+ # *`vm` Running instance of the virtual machine
+ # *`current_class` The class which was moved in `self` structures
+ # *`offset` The offset of block of attributes of `current_class` in `self`
+ fun moved_class_attributes(vm: VirtualMachine, current_class: MClass, offset: Int)
+ do
+ # `current_class` was moved in `self` attribute table
+ if not current_class.positions_attributes.has_key(current_class) then
+ # The invariant position is no longer satisfied
+ current_class.positions_attributes[current_class] = current_class.position_attributes
+ current_class.position_attributes = - current_class.position_attributes
+ else
+ # The class has already several positions and an update is needed
+ current_class.positions_attributes[current_class] = - current_class.positions_attributes[current_class]
+
+ for sub in ordering do
+ if sub == current_class then continue
+
+ var super_id = current_class.vtable.id
+ var mask = sub.vtable.mask
+ vm.load_class(sub)
+
+ if vm.inter_is_subtype_ph(super_id, mask, sub.vtable.internal_vtable) then
+ if not sub.positions_methods.has_key(current_class) then
+ sub.positions_attributes[current_class] = current_class.position_attributes
+ else
+ var old_position = sub.positions_attributes[current_class]
+ if old_position > 0 then
+ # Indicate this class can not used anymore single inheritance implementation
+ sub.positions_attributes[current_class] = - old_position
+ end
+ end
+ end
+ end
+ end
+
+ # Save the position of `current_class` in `self`
+ positions_attributes[current_class] = offset
+ end
+
+ # Return the position of the method's block of class `cl` in `self` if `cl` has an invariant position in self,
+ # Otherwise return a negative position
+ fun get_position_methods(cl: MClass): Int
+ do
+ # The class has an invariant position in all subclasses
+ if cl.position_methods > 0 then return cl.position_methods
+
+ # The position has an invariant position for this class and its subclasses only
+ if positions_methods.has_key(cl) then
+ var pos = positions_methods[cl]
+ if pos > 0 then return pos
+ return -1
+ end
+
+ # No invariant position at all, the caller must use a multiple inheritance implementation
+ return -1
+ end
+
+ # Return the position of the attribute's block of class `cl` in `self` if `cl` has an invariant position in self,
+ # Otherwise return a negative position
+ fun get_position_attributes(cl: MClass): Int
+ do
+ # The class has an invariant position in all subclasses
+ if cl.position_attributes > 0 then return cl.position_attributes
+
+ # The position has an invariant position for this class and its subclasses only
+ if positions_attributes.has_key(cl) then
+ var pos = positions_attributes[cl]
+ if pos > 0 then return pos
+ return -1
+ end
+
+ # No invariant position at all, the caller must use a multiple inheritance implementation
+ return -1
+ end
+end
+
+redef class MProperty
+ # Relative offset of this in the runtime instance
+ # (beginning of the block of its introducing class for attributes or methods)
+ var offset: Int
end
redef class MAttribute
# Relative offset of this attribute in the runtime instance
# (beginning of the block of its introducing class)
- var offset: Int
-
- # Absolute offset of this attribute in the runtime instance (beginning of the attribute table)
- var absolute_offset: Int
+ redef var offset: Int
end
redef class MMethod
# Relative offset of this method in the virtual table (from the beginning of the block)
- var offset: Int
-
- # Absolute offset of this method in the virtual table (from the beginning of the vtable)
- var absolute_offset: Int
+ redef var offset: Int
end
# Redef MutableInstance to improve implementation of attributes in objects
MMethodDef_incr_ref(method);
}
`}
+
+ # Return a NULL pointer, used to initialize virtual tables
+ private fun null_ptr: Pointer `{
+ return NULL;
+ `}
end
callsite.id, callsite.offset)
end
+ #TODO : we need recompilations here
+ callsite.status = 0
return self.call(propdef, args)
end
end
# * `recv` The receiver (The object) of the access
protected fun optimize(mproperty: MAttribute, recv: MutableInstance)
do
- if mproperty.intro_mclassdef.mclass.positions_attributes[recv.mtype.as(MClassType).mclass] != -1 then
+ var position = recv.mtype.as(MClassType).mclass.get_position_attributes(mproperty.intro_mclassdef.mclass)
+ if position > 0 then
# if this attribute class has an unique position for this receiver, then use direct access
- offset = mproperty.absolute_offset
+ offset = position + mproperty.offset
status = 1
else
# Otherwise, perfect hashing must be used
abort
end
+ #TODO : we need recompilations here
+ status = 0
+
return i
end
end
v.write_attribute_ph(recv.internal_attributes, recv.vtable.internal_vtable,
recv.vtable.mask, id, offset, i)
end
+
+ #TODO : we need recompilations here
+ status = 0
end
end
# Otherwise we must use perfect hashing
fun optimize(recv: Instance)
do
- if mproperty.intro_mclassdef.mclass.positions_methods[recv.mtype.as(MClassType).mclass] != -1 then
- offset = mproperty.absolute_offset
+ var position = recv.mtype.as(MClassType).mclass.get_position_methods(mproperty.intro_mclassdef.mclass)
+ if position > 0 then
+ offset = position + mproperty.offset
status = 1
else
offset = mproperty.offset
var recv = v.expr(self.n_expr)
if recv == null then return null
- if status == 0 then optimize(v, recv.mtype, self.cast_type.as(not null))
+ optimize(v, recv.mtype, self.cast_type.as(not null))
var mtype = v.unanchor_type(self.cast_type.as(not null))
# If this test can be optimized, directly call appropriate subtyping methods
return
end
- if not target.mclass.loaded then return
+ if not target.mclass.abstract_loaded then return
- # Try to get the position of the target type in source's structures
- var value = source.mclass.positions_methods.get_or_null(target.mclass)
-
- if value != null then
- if value != -1 then
- # Store informations for Cohen test
- position = target.mclass.color
- status = 1
- else
- # We use perfect hashing
- status = 2
- end
+ # If the value is positive, the target class has an invariant position in source's structures
+ var value = source.mclass.get_position_methods(target.mclass)
+
+ if value > 0 then
+ # `value - 2` is the position of the target identifier in source vtable
+ position = value - 2
+ status = 1
+ else
+ # We use perfect hashing
+ status = 2
end
id = target.mclass.vtable.id
end
var recv = v.expr(self.n_expr)
if recv == null then return null
- if status == 0 then optimize(v, recv.mtype, self.mtype.as(not null))
+ optimize(v, recv.mtype, self.mtype.as(not null))
var mtype = self.mtype.as(not null)
var amtype = v.unanchor_type(mtype)
if not target.mclass.loaded then return
- # Try to get the position of the target type in source's structures
- var value = source.mclass.positions_methods.get_or_null(target.mclass)
-
- if value != null then
- if value != -1 then
- # Store informations for Cohen test
- position = target.mclass.color
- status = 1
- else
- # We use perfect hashing
- status = 2
- end
+ # If the value is positive, the target class has an invariant position in source's structures
+ var value = source.mclass.get_position_methods(target.mclass)
+
+ if value > 0 then
+ # `value - 2` is the position of the target identifier in source vtable
+ position = value - 2
+ status = 1
+ else
+ # We use perfect hashing
+ status = 2
end
id = target.mclass.vtable.id
end
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import standard::kernel
+
+var b = 0b_
+var x = 0x_
+var o = 0o_
var b: Object is noautoinit
#alt1#var b2: Object = get(-4) is noautoinit
var c: Object is noautoinit
- var d: Object = get(2) is autoinit
- #alt2#var d2: Object = get(-2) is autoinit, lazy
+ var d: Object = get(2) is lateinit
+ #alt2#var d2: Object = get(-2) is lateinit, lazy
var e: Object = get(1)
fun setc(v: Object) is autoinit do self.c = get(v)
init do
noautoinit #alt6#
#alt6,7# autoinit
super A
- var a: A
+ var a: A #alt9#
end
class F
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+intrude import standard::collection::array
+
+var a = new Array[Bool]
+var cpt = 0
+while cpt < 20 do
+ a.push(false)
+ cpt += 1
+end
+
+for i in a do i.output
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import standard::kernel
+
+assert 0b1001 == 0x09
+assert 0o715 == 0x1CD
+assert 461 == 0o715
+assert 0b111001101 == 0o715
+assert 256 == 0x100
+assert 0o400 == 256
+assert 0b1_1100_1101 == 0o715
+assert 0b1_1100_1101 == 0x1_CD
--- /dev/null
+--no-color -W test_advice_repeated_types.nit
-base_simple3.nit A
-base_simple3.nit foo
-base_simple3.nit base_simple3
+base_simple3.nit -q A
+base_simple3.nit -q foo
+base_simple3.nit -q base_simple3
--- /dev/null
+base_error_literal.nit:17,9--11: Error: invalid binary literal
+base_error_literal.nit:18,9--11: Error: invalid hexadecimal literal
+base_error_literal.nit:19,9--11: Error: invalid octal literal
-alt/base_init_autoinit2_alt2.nit:23,40--43: Error: `lazy` incompatible with `autoinit`.
+alt/base_init_autoinit2_alt2.nit:23,40--43: Error: `lazy` incompatible with `lateinit`.
--- /dev/null
+1
+2
+false
+3
+3.300000
+4
+true
+4.400000
--- /dev/null
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
+false
--- /dev/null
+../lib/standard/bytes.nit:51,7--19: Documentation warning: Undocumented property `with_capacity`
+../lib/standard/bytes.nit:164,6--13: Documentation warning: Undocumented property `to_bytes`
+../lib/standard/stream.nit:425,6--17: Documentation warning: Undocumented property `buffer_reset`
+../lib/standard/file.nit:444,6--19: Documentation warning: Undocumented property `read_all_bytes`
+test_advice_repeated_types.nit:36,15--20: Warning: useless type repetition on redefined attribute `_a`
+test_advice_repeated_types.nit:37,18--20: Warning: useless type repetition on parameter `b1` for redefined method `b`
+test_advice_repeated_types.nit:38,18--20: Warning: useless type repetition on parameter `c1` for redefined method `c`
+test_advice_repeated_types.nit:38,27--29: Warning: useless type repetition on parameter `c2` for redefined method `c`
+test_advice_repeated_types.nit:39,15--20: Warning: useless return type repetition for redefined method `d`
+test_advice_repeated_types.nit:40,18--20: Warning: useless type repetition on parameter `e1` for redefined method `e`
+test_advice_repeated_types.nit:40,24--29: Warning: useless return type repetition for redefined method `e`
+test_advice_repeated_types.nit:49,18--20: Warning: useless type repetition on parameter `e1` for redefined method `e`
printf( "received msg: %s, of length = %d\n", c_msg, msg_len );
/* A_my_attr is a callback to the getter of self.my_attr */
- printf( "old attr %d\n", A_my_attr(recv) );
+ printf( "old attr %d\n", A_my_attr(self) );
if(chose)
truc;
chose;
/* A_my_attr is a callback to the setter of self.my_attr= */
- A_my_attr__assign( recv, msg_len );
+ A_my_attr__assign( self, msg_len );
`}
end
extern class TimeT `{time_t`}
new `{ return time(NULL); `}
new from_i(i: Int) `{ return i; `}
- fun update `{ time(&recv); `}
+ fun update `{ time(&self); `}
fun ctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( ctime(&recv) );
+ return NativeString_to_s_with_copy( ctime(&self) );
`}
# Difference in secondes from start (self if the end time)
- fun difftime(start: TimeT): Float `{ return difftime(recv, start); `}
+ fun difftime(start: TimeT): Float `{ return difftime(self, start); `}
private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]): nullable Int is
extern import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{`}
fun address_is_null: Bool is extern "address_is_null"
-fun free `{ free(recv); `}
+fun free `{ free(self); `}
printf( "received msg: %s, of length = %d\n", c_msg, msg_len );
/* A_my_attr is a callback to the getter of self.my_attr */
- printf( "old attr %d\n", A_my_attr(recv) );
+ printf( "old attr %d\n", A_my_attr(self) );
if(chose)
truc;
chose;
/* A_my_attr is a callback to the setter of self.my_attr= */
- A_my_attr__assign( recv, msg_len );
+ A_my_attr__assign( self, msg_len );
`}
end
new `{ return time(NULL); `}
new from_i(i: Int) `{ return i; `}
- fun update `{ time(&recv); `}
+ fun update `{ time(&self); `}
fun ctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( ctime(&recv) );
+ return NativeString_to_s_with_copy( ctime(&self) );
`}
# Difference in secondes from start (self if the end time)
- fun difftime(start: TimeT): Float `{ return difftime(recv, start); `}
+ fun difftime(start: TimeT): Float `{ return difftime(self, start); `}
private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]): nullable Int is
extern import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{`}
fun address_is_null: Bool is extern "address_is_null"
-fun free `{ free(recv); `}
+fun free `{ free(self); `}
if name == "Array[nullable Object]" then return new Array[nullable Object].from_deserializer(self)
if name == "Array[Serializable]" then return new Array[Serializable].from_deserializer(self)
if name == "Array[Object]" then return new Array[Object].from_deserializer(self)
- if name == "HashMap[Serializable, Array[Couple[Serializable, Int]]]" then return new HashMap[Serializable, Array[Couple[Serializable, Int]]].from_deserializer(self)
- if name == "Array[Couple[Serializable, Int]]" then return new Array[Couple[Serializable, Int]].from_deserializer(self)
return super
end
end
-Usage: nitx [OPTION]... <file.nit> [query]
+Usage: nitx [OPTION]... <file.nit>... [query]
Displays specific pieces of API information from Nit source files.
Use --help for help
-\e[1m= result for 'A'\e[0m
- class \e[32m\e[1mA\e[0m\e[0m
- \e[30m\e[1mbase_simple3::A\e[0m\e[0m\e[30m (lines 29-32)\e[0m
-
- \e[1m== supers\e[0m
-
- interface \e[32m\e[1mObject\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Object\e[0m\e[0m\e[30m (lines 19-20)\e[0m
-
- \e[1m== constructors\e[0m
-
- redef \e[1m\e[32minit\e[0m\e[0m
- \e[30m\e[1mbase_simple3::A::init\e[0m\e[0m\e[30m (lines 30-30)\e[0m
-
- \e[1m== methods\e[0m
-
- fun \e[1m\e[32mrun\e[0m\e[0m
- \e[30m\e[1mbase_simple3::A::run\e[0m\e[0m\e[30m (lines 31-31)\e[0m
-
- \e[1m== refinements\e[0m
+\e[1m\e[32m# 2 result(s) for 'comment: A'\e[m\e[m
+
+ \e[1m\e[32mC\e[m\e[m \e[1m\e[34mA\e[m\e[m
+ \e[1m\e[30mbase_simple3::A\e[m\e[m
+ class A
+ \e[30mbase_simple3.nit:29,1--32,3\e[m
+
+ \e[1m\e[32mC\e[m\e[m \e[1m\e[34mA\e[m\e[m
+ \e[1m\e[30mbase_simple3::base_simple3::A\e[m\e[m
+ class A
+ \e[30mbase_simple3.nit:29,1--32,3\e[m
-\e[1m= result for 'foo'\e[0m
- fun \e[1m\e[32mfoo\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Sys::foo\e[0m\e[0m\e[30m (lines 49-49)\e[0m
+\e[1m\e[32m# 2 result(s) for 'comment: foo'\e[m\e[m
+
+ \e[1m\e[32mF\e[m\e[m \e[1m\e[34mfoo\e[m\e[m
+ \e[1m\e[30mbase_simple3::Sys::foo\e[m\e[m
+ fun foo
+ \e[30mbase_simple3.nit:49,1--19\e[m
+
+ \e[1m\e[32mF\e[m\e[m \e[1m\e[34mfoo\e[m\e[m
+ \e[1m\e[30mbase_simple3::base_simple3::Sys::foo\e[m\e[m
+ fun foo
+ \e[30mbase_simple3.nit:49,1--19\e[m
-\e[1m= result for 'base_simple3'\e[0m
- module \e[1mbase_simple3\e[0m
- \e[30m\e[1mbase_simple3\e[0m\e[0m\e[30m (lines 17-66)\e[0m
-
- \e[1m== introduced classes\e[0m
-
- class \e[32m\e[1mA\e[0m\e[0m
- \e[30m\e[1mbase_simple3::A\e[0m\e[0m\e[30m (lines 29-32)\e[0m
-
- class \e[32m\e[1mB\e[0m\e[0m
- \e[30m\e[1mbase_simple3::B\e[0m\e[0m\e[30m (lines 34-42)\e[0m
-
- enum \e[32m\e[1mBool\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Bool\e[0m\e[0m\e[30m (lines 22-23)\e[0m
-
- class \e[32m\e[1mC\e[0m\e[0m
- \e[30m\e[1mbase_simple3::C\e[0m\e[0m\e[30m (lines 44-47)\e[0m
-
- enum \e[32m\e[1mInt\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Int\e[0m\e[0m\e[30m (lines 25-27)\e[0m
-
- interface \e[32m\e[1mObject\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Object\e[0m\e[0m\e[30m (lines 19-20)\e[0m
-
- class \e[32m\e[1mSys\e[0m\e[0m
- \e[30m\e[1mbase_simple3::Sys\e[0m\e[0m\e[30m (lines 49-49)\e[0m
+\e[1m\e[32m# 3 result(s) for 'comment: base_simple3'\e[m\e[m
+
+ \e[1m\e[32mP\e[m\e[m \e[1m\e[34mbase_simple3\e[m\e[m
+ \e[1m\e[30mbase_simple3\e[m\e[m
+ project base_simple3
+ \e[30mbase_simple3.nit:17,1--66,13\e[m
+
+ \e[1m\e[32mG\e[m\e[m \e[1m\e[34mbase_simple3\e[m\e[m
+ \e[1m\e[30mbase_simple3\e[m\e[m
+ group base_simple3
+ \e[30mbase_simple3.nit:17,1--66,13\e[m
+
+ \e[1m\e[32mM\e[m\e[m \e[1m\e[34mbase_simple3\e[m\e[m
+ \e[1m\e[30mbase_simple3::base_simple3\e[m\e[m
+ module base_simple3
+ \e[30mbase_simple3.nit:17,1--66,13\e[m
-Runtime error: Cast failed. Expected `E`, got `Bool` (../lib/standard/collection/array.nit:960)
+Runtime error: Cast failed. Expected `E`, got `Bool` (../lib/standard/collection/array.nit:957)
NativeString
N
Nit
+++ /dev/null
-28
-ハaロЖー𐍃a世界 ᓀ . ᓂ A,𐍆 a日本A語aです
-ハaロЖー𐍃a世界 ᓀ . ᓂ A,𐍆 a日本A語aです
-すでa語A本日a 𐍆,A ᓂ . ᓀ 界世a𐍃ーЖロaハ
-ー𐍃a世
-世a𐍃ー
-世a𐍃ー
-ー𐍃a世
-すでa語A本日a 𐍆,A ᓂ . ᓀ 界世a𐍃ーЖロaハ
-ハaロЖー𐍃a世界 ᓀ . ᓂ A,𐍆 a日本A語aです
-ハAロЖー𐍃A世界 ᓀ . ᓂ A,𐍆 A日本A語Aです
-ハaロЖー𐍃a世界 ᓀ . ᓂ a,𐍆 a日本a語aです
-aハロЖー𐍃a世界 ᓀ . ᓂ A,𐍆 a日本A語aです
-aハロЖー𐍃a世界 ᓀ . ᓂ a,𐍆 a日本a語aです
-AハロЖー𐍃A世界 ᓀ . ᓂ A,𐍆 A日本A語Aです
-すでA語A本日A 𐍆,A ᓂ . ᓀ 界世A𐍃ーЖロハA
char* string = "This is a test string";
FlatString ref_string = NativeString_to_s(string);
- StringTest_ref_test(recv, ref_string);
+ StringTest_ref_test(self, ref_string);
FlatString copy_string = NativeString_to_s_with_copy(string);
- StringTest_copy_test(recv, copy_string);
+ StringTest_copy_test(self, copy_string);
int same_refs = FlatString_items(copy_string) == FlatString_items(ref_string);
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class A
+ var a: Object
+ fun b(b1: Int) is abstract
+ fun c(c1: Int, c2: Int) is abstract
+ fun d: Object is abstract
+ fun e(e1: Int): Object is abstract
+end
+
+class B
+ super A
+
+ redef var a
+ redef fun b(b1) do end
+ redef fun c(c1, c2) do end
+ redef fun d do return ""
+ redef fun e(e1) do return ""
+end
+
+class C
+ super A
+
+ redef var a: Object
+ redef fun b(b1: Int) do end
+ redef fun c(c1: Int, c2: Int) do end
+ redef fun d: Object do return ""
+ redef fun e(e1: Int): Object do return ""
+end
+
+class D
+ super A
+
+ redef fun b(b1) do end
+ redef fun c(c1, c2) do end
+ redef fun d: Int do return 1
+ redef fun e(e1: Int): Numeric do return 1
+end
+
+class E
+ super A
+
+ redef var d: Int = 1
+end
info = curl.easy_getinfo_long(new CURLInfoLong.rtsp_server_cseq)
assert infoResp:info != null
-info = curl.easy_getinfo_long(new CURLInfoLong.rtsp_cseq_recv)
+info = curl.easy_getinfo_long(new CURLInfoLong.rtsp_cseq_self)
assert infoResp:info != null
# Double
fun print_all import String.to_cstring, r, rw `{
printf( "%s %s\n",
- String_to_cstring( A_r( recv ) ),
- String_to_cstring( A_rw( recv ) ) );
+ String_to_cstring( A_r( self ) ),
+ String_to_cstring( A_rw( self ) ) );
`}
fun modify import NativeString.to_s, w=, rw= `{
- A_w__assign( recv, NativeString_to_s( "w set from native" ) );
- A_rw__assign( recv, NativeString_to_s( "rw set from native" ) );
+ A_w__assign( self, NativeString_to_s( "w set from native" ) );
+ A_rw__assign( self, NativeString_to_s( "rw set from native" ) );
`}
end
int i;
for(i = 0; i < 2000; ++i) {
printf("%d\n", i);
- Test_foo(recv, NativeString_to_s("asdf"));
+ Test_foo(self, NativeString_to_s("asdf"));
}
`}
fun foo do print "foo"
fun call_a_fun import foo `{
- Sys_foo(recv);
+ Sys_foo(self);
`}
fun call_a_constructor import A, A.bar `{
if ( n == 1 )
return 1;
else
- return FibonacciEngine_fibonacci( recv, n-1 ) + FibonacciEngine_fibonacci( recv, n-2 );
+ return FibonacciEngine_fibonacci( self, n-1 ) + FibonacciEngine_fibonacci( self, n-2 );
`}
end
redef class Int
fun fibonacci : Int import fibonacci `{
- if ( recv == 0 )
+ if ( self == 0 )
return 0;
- else if ( recv == 1 )
+ else if ( self == 1 )
return 1;
else
- return Int_fibonacci( recv-1 ) + Int_fibonacci( recv-2 );
+ return Int_fibonacci( self-1 ) + Int_fibonacci( self-2 );
`}
end
`}
fun []=(i: Int, v: A) `{
- recv[i] = v;
+ self[i] = v;
A_incr_ref(v);
`}
fun [](i: Int): A `{
- return recv[i];
+ return self[i];
`}
end
`}
fun p : Int import m `{
- return A_m( recv ) + 5;
+ return A_m( self ) + 5;
`}
fun in_language : Int is extern in "C" `{
fun out(i: Int, f: Float): Int import in1, in2, A, A.alt, A.to_i `{
printf("From C, beginning out: %ld\n", i);
- Sys_in1(recv, i);
+ Sys_in1(self, i);
A a = new_A();
A b = new_A_alt(10);
printf("From C, a=%ld\n", A_to_i(a));
fun a do print "a"
fun p `{
- printf( "allo from %i\n", *recv );
+ printf( "allo from %i\n", *self );
`}
fun d : A import d, A `{
return new_A();
`}
redef fun to_s import NativeString, NativeString.to_s `{
- int len = snprintf(NULL, 0, "%d", *recv) + 1;
+ int len = snprintf(NULL, 0, "%d", *self) + 1;
char *c = new_NativeString(len);
- sprintf(c, "%d", *recv);
+ sprintf(c, "%d", *self);
return NativeString_to_s(c);
`}
end
init(value: Int) do self.value = value
fun +(other: A): A import value, A `{
- int s = A_value( recv );
+ int s = A_value( self );
int o = A_value( other );
return new_A( s + o );
`}
fun +: A import value, A `{
- int s = A_value(recv);
+ int s = A_value(self);
return new_A(+s);
`}
fun -(other: A): A import value, A `{
- int s = A_value( recv );
+ int s = A_value( self );
int o = A_value( other );
return new_A( s - o );
`}
fun -: A import value, A `{
- int s = A_value(recv);
+ int s = A_value(self);
return new_A(-s);
`}
fun *(by: Int): A import value, A `{
- int s = A_value( recv );
+ int s = A_value( self );
return new_A( s * by );
`}
fun /(by: Int): A import value, A `{
- int s = A_value( recv );
+ int s = A_value( self );
return new_A( s / by );
`}
redef fun ==(other) import value, nullable Object.as(A) `{
if ( nullable_Object_is_a_A( other ) &&
- A_value( nullable_Object_as_A(other) ) == A_value( recv ) )
+ A_value( nullable_Object_as_A(other) ) == A_value( self ) )
return 1;
else
return 0;
`}
fun %(other: A): A import value, A `{
- return new_A( A_value( recv ) % A_value( other ) );
+ return new_A( A_value( self ) % A_value( other ) );
`}
fun <=>(other: A): A import value, A `{
- return new_A( A_value( recv )* 1024 );
+ return new_A( A_value( self )* 1024 );
`}
fun >(other: A): Bool import value `{
- return A_value( recv ) > A_value( other );
+ return A_value( self ) > A_value( other );
`}
fun <(other: A): Bool import value `{
- return A_value( recv ) < A_value( other );
+ return A_value( self ) < A_value( other );
`}
fun >=(other: A): Bool import value `{
- return A_value( recv ) >= A_value( other );
+ return A_value( self ) >= A_value( other );
`}
fun <=(other: A): Bool import value `{
- return A_value( recv ) <= A_value( other );
+ return A_value( self ) <= A_value( other );
`}
fun >>(other: A): A import value, value=, A `{
- int new_val = A_value( recv ) >> A_value( other );
+ int new_val = A_value( self ) >> A_value( other );
return new_A(new_val);
`}
fun <<(other: A): A import value, A `{
- int new_val = A_value( recv ) << A_value( other );
+ int new_val = A_value( self ) << A_value( other );
return new_A(new_val);
`}
fun |(other: A): A import value, A `{
- int new_val = A_value( recv ) | A_value( other );
+ int new_val = A_value( self ) | A_value( other );
return new_A(new_val);
`}
fun ^(other: A): A import value, A `{
- int new_val = A_value( recv ) ^ A_value( other );
+ int new_val = A_value( self ) ^ A_value( other );
return new_A(new_val);
`}
fun ~: A import value, A `{
- int new_val = ~A_value( recv );
+ int new_val = ~A_value( self );
return new_A(new_val);
`}
fun &(other: A): A import value, A `{
- int new_val = A_value( recv ) & A_value( other );
+ int new_val = A_value( self ) & A_value( other );
return new_A(new_val);
`}
redef fun id : String import super, NativeString.to_s, String.to_cstring `{
char *new_name;
char *prefix = "B special ";
- char *super_name = String_to_cstring( B_id___super( recv ) );
+ char *super_name = String_to_cstring( B_id___super( self ) );
new_name = calloc( strlen( prefix )+strlen( super_name )+1, sizeof(char) );
strcpy( new_name, prefix );
return v;
`}
fun p `{
- printf( "A< %d %d >\n", recv->x, recv->y );
+ printf( "A< %d %d >\n", self->x, self->y );
`}
end
`}
redef fun p import super `{
printf( "B< " );
- B_p___super(recv);
- printf( " %d %d >\n", recv->w, recv->h );
+ B_p___super(self);
+ printf( " %d %d >\n", self->w, self->h );
`}
end
return v;
`}
redef fun p `{
- printf( "C< %d %d >\n", recv->x, recv->y );
+ printf( "C< %d %d >\n", self->x, self->y );
`}
end
# Adds an element to the end of the vector
fun push(v: Int) in "C++" `{
- recv->push_back(v);
+ self->push_back(v);
`}
# Pops an element from the end of the vector
fun pop: Int in "C++" `{
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
`}
fun safe_pop_with_default(default_return: Int): Int import report_error in "C++" `{
- if (recv->empty()) {
- CppVector_report_error(recv);
+ if (self->empty()) {
+ CppVector_report_error(self);
return default_return;
} else {
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
}
`}
# Adds an element to the end of the vector
fun push(v: Int) in "C++" `{
- recv->push_back(v);
+ self->push_back(v);
`}
# Pops an element from the end of the vector
fun pop: Int in "C++" `{
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
`}
# Uses a callback to report when receiver is empty
fun safe_pop_with_default(default_return: Int): Int import report_error in "C++" `{
- if (recv->empty()) {
- CppVector_report_error(recv);
+ if (self->empty()) {
+ CppVector_report_error(self);
return default_return;
} else {
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
}
`}
# Prints the given string when receiver is empty
fun safe_pop_with_custom_error(default_return: Int, error_msg: String): Int import String.to_cpp_string in "C++" `{
- if (recv->empty()) {
+ if (self->empty()) {
string *cpp_error_msg = String_to_cpp_string(error_msg);
cout << *cpp_error_msg << "\n";
return default_return;
} else {
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
}
`}
# Adds an element to the end of the vector
fun push(v: Int) in "C++" `{
- recv->push_back(v);
+ self->push_back(v);
`}
# Pops an element from the end of the vector
fun pop: Int in "C++" `{
- long val = recv->back();
- recv->pop_back();
+ long val = self->back();
+ self->pop_back();
return val;
`}
end
fun i: Int do return 777
fun foo import bar, i in "Java" `{
- A_bar(recv);
- long i = A_i(recv);
+ A_bar(self);
+ long i = A_i(self);
System.out.println(i);
`}
return new LinkedBlockingQueue<String>();
`}
- fun offer(o: JavaString) in "Java" `{ recv.offer(o); `}
+ fun offer(o: JavaString) in "Java" `{ self.offer(o); `}
- fun remove: JavaString in "Java" `{ return recv.remove(); `}
+ fun remove: JavaString in "Java" `{ return self.remove(); `}
redef fun output in "Java" `{
- for (String s: recv) {
+ for (String s: self) {
System.out.println(s);
}
`}
System.out.println(input);
// Callback Nit with string
- String str = A_bar(recv, "Created in Java");
+ String str = A_bar(self, "Created in Java");
System.out.println(str);
// Send back a string
return new ArrayList();
`}
- fun add(o: JavaString) in "Java" `{ recv.add(o); `}
+ fun add(o: JavaString) in "Java" `{ self.add(o); `}
redef fun output in "Java" `{
- for (Object i: recv) {
+ for (Object i: self) {
System.out.println((String)i);
}
`}
fun sort in "Java" `{
- Collections.sort(recv);
+ Collections.sort(self);
`}
end
printf("From Objective-C: %ld %f %s\n", ii, f, cstr);
- Sys_bar(recv, ii, f, s);
+ Sys_bar(self, ii, f, s);
`}
fun bar(i: Int, f: Float, s: String)
printf( "received msg: %s, of length = %d\n", c_msg, msg_len );
/* A_my_attr is a callback to the getter of self.my_attr */
- printf( "old attr %d\n", A_my_attr(recv) );
+ printf( "old attr %d\n", A_my_attr(self) );
if(chose)
truc;
chose;
/* A_my_attr is a callback to the setter of self.my_attr= */
- A_my_attr__assign( recv, msg_len );
+ A_my_attr__assign( self, msg_len );
`}
end
new `{ return time(NULL); `}
new from_i(i: Int) `{ return i; `}
- fun update `{ time(&recv); `}
+ fun update `{ time(&self); `}
fun ctime: String import NativeString.to_s_with_copy `{
- return NativeString_to_s_with_copy( ctime(&recv) );
+ return NativeString_to_s_with_copy( ctime(&self) );
`}
# Difference in secondes from start (self if the end time)
- fun difftime(start: TimeT): Float `{ return difftime(recv, start); `}
+ fun difftime(start: TimeT): Float `{ return difftime(self, start); `}
private fun intern_poll(in_fds: Array[Int], out_fds: Array[Int]) : nullable Int is extern import Array[Int].length, Array[Int].[], Int.as(nullable Int) `{`}
end
fun address_is_null: Bool is extern "address_is_null"
-fun free `{ free(recv); `}
+fun free `{ free(self); `}
* `nitmetrics`
* `nitx`
* or others `modelbuilder`.
-
Fictive Crappy Platform.
-
Role Playing Game group
-
--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import more_collections
+
+var ul = new UnrolledList[Object]
+var ll = new List[Object]
+
+for i in 1000.times do
+ var val = 100.rand+1
+
+ var act = 3.rand
+ #print "+"+act.to_s
+ if act == 0 then
+ ll.add val
+ ul.add val
+ else if act == 1 then
+ ll.unshift val
+ ul.unshift val
+ else if act == 2 then
+ var index = ll.length.rand
+ ll.insert(val, index)
+ ul.insert(val, index)
+ else abort
+
+ #assert ll == ul
+end
+
+for i in 200.times do
+ var act = 3.rand
+ #print "-"+act.to_s
+ if act == 0 then
+ var o = ll.pop
+ var c = ul.pop
+ assert o == c
+ else if act == 1 then
+ var o = ll.shift
+ var c = ul.shift
+ assert o == c
+ else if act == 2 then
+ var index = ll.length.rand
+ ll.remove_at(index)
+ ul.remove_at(index)
+ else abort
+
+ #assert ll == ul
+end
+
+while ul.not_empty do
+ var c = ul.shift
+ var o = ll.shift
+ assert c == o else print "{c} vs {o}"
+end
+assert ll.is_empty
+++ /dev/null
-# This file is part of NIT ( http://www.nitlanguage.org ).
-#
-# This file is free software, which comes along with NIT. This software 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. You can modify it is you want, provided this header
-# is kept unaltered, and a notification of the changes is added.
-# You are allowed to redistribute it and sell it, alone or is a part of
-# another product.
-
-import standard
-intrude import string_experimentations::utf8_noindex
-
-var s = "aàハ𐍆".as(FlatString)
-assert s.char_at(0).code_point == 97
-assert s.char_at(1).code_point == 224
-assert s.char_at(2).code_point == 12495
-assert s.char_at(3).code_point == 66374
-
-var str = "ハaロЖー𐍃a世界 ᓀ . ᓂ A,𐍆 a日本A語aです".as(FlatString)
-
-print str.length
-print str
-
-for i in [0 .. str.length[ do
- str.char_at(i).output
-end
-
-'\n'.output
-
-var ss = str.reversed.as(FlatString)
-
-for i in [0 .. ss.length[ do ss.char_at(i).output
-
-'\n'.output
-
-var x = str.substring(4,4).as(FlatString)
-
-for i in [0 .. x.length[ do x.char_at(i).output
-
-'\n'.output
-
-var xx = x.reversed.as(FlatString)
-
-for i in [0 .. xx.length[ do xx.char_at(i).output
-
-'\n'.output
-
-var it = new FlatStringReviter(x)
-for i in it do
- i.output
-end
-
-'\n'.output
-
-var it2 = new FlatStringIter(x)
-for i in it2 do
- i.output
-end
-
-'\n'.output
-
-it = new FlatStringReviter(str)
-for i in it do
- i.output
-end
-
-'\n'.output
-
-it2 = new FlatStringIter(str)
-for i in it2 do
- i.output
-end
-
-'\n'.output
-
-assert str * 2 == str + str
-
-assert x * 2 == x + x
-
-print str.to_upper
-
-print str.to_lower
-
-var buf = new FlatBuffer.from(str)
-
-buf.append str
-
-var bf = new FlatBuffer.from(str)
-
-bf.times(2)
-
-assert bf == buf
-
-var bf2 = new FlatBuffer.from(str)
-
-bf2.char_at(0) = str.char_at(1)
-bf2.char_at(1) = str.char_at(0)
-
-for i in [0 .. bf2.length[ do bf2.char_at(i).output
-
-'\n'.output
-
-bf2.lower
-
-for i in [0 .. bf2.length[ do bf2.char_at(i).output
-
-'\n'.output
-
-bf2.upper
-
-for i in [0 .. bf2.length[ do bf2.char_at(i).output
-
-'\n'.output
-
-bf2.reverse
-
-for i in [0 .. bf2.length[ do bf2.char_at(i).output
-
-'\n'.output
nitlanguage / nit.git / commitdiff