content
stringlengths 4
1.04M
| lang
stringclasses 358
values | score
int64 0
5
| repo_name
stringlengths 5
114
| repo_path
stringlengths 4
229
| repo_licenses
sequencelengths 1
8
|
|---|---|---|---|---|---|
// <copyright file="SafariDriver.cs" company="WebDriver Committers">
// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The SFC licenses this file
// to you 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.
// </copyright>
using System;
using System.Collections.Generic;
using OpenQA.Selenium.Remote;
namespace OpenQA.Selenium.Safari
{
/// <summary>
/// Provides a way to access Safari to run your tests by creating a SafariDriver instance
/// </summary>
/// <remarks>
/// When the WebDriver object has been instantiated the browser will load. The test can then navigate to the URL under test and
/// start your test.
/// </remarks>
/// <example>
/// <code>
/// [TestFixture]
/// public class Testing
/// {
/// private IWebDriver driver;
/// <para></para>
/// [SetUp]
/// public void SetUp()
/// {
/// driver = new SafariDriver();
/// }
/// <para></para>
/// [Test]
/// public void TestGoogle()
/// {
/// driver.Navigate().GoToUrl("http://www.google.co.uk");
/// /*
/// * Rest of the test
/// */
/// }
/// <para></para>
/// [TearDown]
/// public void TearDown()
/// {
/// driver.Quit();
/// driver.Dispose();
/// }
/// }
/// </code>
/// </example>
public class SafariDriver : WebDriver
{
private const string AttachDebuggerCommand = "attachDebugger";
private const string GetPermissionsCommand = "getPermissions";
private const string SetPermissionsCommand = "setPermissions";
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class.
/// </summary>
public SafariDriver()
: this(new SafariOptions())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified <see cref="SafariOptions"/>.
/// </summary>
/// <param name="options">The <see cref="SafariOptions"/> to use for this <see cref="SafariDriver"/> instance.</param>
public SafariDriver(SafariOptions options)
: this(SafariDriverService.CreateDefaultService(), options)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified driver service.
/// </summary>
/// <param name="service">The <see cref="SafariDriverService"/> used to initialize the driver.</param>
public SafariDriver(SafariDriverService service)
: this(service, new SafariOptions())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified path
/// to the directory containing safaridriver.
/// </summary>
/// <param name="safariDriverDirectory">The full path to the directory containing SafariDriver executable.</param>
public SafariDriver(string safariDriverDirectory)
: this(safariDriverDirectory, new SafariOptions())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified path
/// to the directory containing safaridriver and options.
/// </summary>
/// <param name="safariDriverDirectory">The full path to the directory containing SafariDriver executable.</param>
/// <param name="options">The <see cref="SafariOptions"/> to be used with the Safari driver.</param>
public SafariDriver(string safariDriverDirectory, SafariOptions options)
: this(safariDriverDirectory, options, RemoteWebDriver.DefaultCommandTimeout)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified path
/// to the directory containing safaridriver, options, and command timeout.
/// </summary>
/// <param name="safariDriverDirectory">The full path to the directory containing SafariDriver executable.</param>
/// <param name="options">The <see cref="SafariOptions"/> to be used with the Safari driver.</param>
/// <param name="commandTimeout">The maximum amount of time to wait for each command.</param>
public SafariDriver(string safariDriverDirectory, SafariOptions options, TimeSpan commandTimeout)
: this(SafariDriverService.CreateDefaultService(safariDriverDirectory), options, commandTimeout)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified
/// <see cref="SafariDriverService"/> and options.
/// </summary>
/// <param name="service">The <see cref="SafariDriverService"/> to use.</param>
/// <param name="options">The <see cref="SafariOptions"/> used to initialize the driver.</param>
public SafariDriver(SafariDriverService service, SafariOptions options)
: this(service, options, RemoteWebDriver.DefaultCommandTimeout)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SafariDriver"/> class using the specified <see cref="SafariDriverService"/>.
/// </summary>
/// <param name="service">The <see cref="SafariDriverService"/> to use.</param>
/// <param name="options">The <see cref="SafariOptions"/> to be used with the Safari driver.</param>
/// <param name="commandTimeout">The maximum amount of time to wait for each command.</param>
public SafariDriver(SafariDriverService service, SafariOptions options, TimeSpan commandTimeout)
: base(new DriverServiceCommandExecutor(service, commandTimeout), ConvertOptionsToCapabilities(options))
{
this.AddCustomSafariCommand(AttachDebuggerCommand, HttpCommandInfo.PostCommand, "/session/{sessionId}/apple/attach_debugger");
this.AddCustomSafariCommand(GetPermissionsCommand, HttpCommandInfo.GetCommand, "/session/{sessionId}/apple/permissions");
this.AddCustomSafariCommand(SetPermissionsCommand, HttpCommandInfo.PostCommand, "/session/{sessionId}/apple/permissions");
}
/// <summary>
/// This opens Safari's Web Inspector.
/// If driver subsequently executes script of "debugger;"
/// the execution will pause, no additional commands will be processed, and the code will time out.
/// </summary>
public void AttachDebugger()
{
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters["attachDebugger"] = null;
this.Execute(AttachDebuggerCommand, parameters);
}
/// <summary>
/// Set permission of an item on the browser. The only supported permission at this time is "getUserMedia".
/// </summary>
/// <param name="permissionName">The name of the item to set permission on.</param>
/// <param name="permissionValue">Whether the permission has been granted.</param>
public void SetPermission(string permissionName, bool permissionValue)
{
if (string.IsNullOrEmpty(permissionName))
{
throw new ArgumentNullException(nameof(permissionName), "permission must not be null or the empty string");
}
Dictionary<string, object> permissions = new Dictionary<string, object>();
permissions[permissionName] = permissionValue;
Dictionary<string, object> parameters = new Dictionary<string, object>();
parameters["permissions"] = permissions;
this.Execute(SetPermissionsCommand, parameters);
}
/// <summary>
/// Returns Each available permission item and whether it is allowed or not.
/// </summary>
/// <returns>whether the item is allowed or not.</returns>
public Object GetPermissions()
{
Response response = this.Execute(GetPermissionsCommand, null);
return response.Value;
}
/// <summary>
/// Gets or sets the <see cref="IFileDetector"/> responsible for detecting
/// sequences of keystrokes representing file paths and names.
/// </summary>
/// <remarks>The Safari driver does not allow a file detector to be set,
/// as the server component of the Safari driver (the Safari extension) only
/// allows uploads from the local computer environment. Attempting to set
/// this property has no effect, but does not throw an exception. If you
/// are attempting to run the Safari driver remotely, use <see cref="RemoteWebDriver"/>
/// in conjunction with a standalone WebDriver server.</remarks>
public override IFileDetector FileDetector
{
get { return base.FileDetector; }
set { }
}
private static ICapabilities ConvertOptionsToCapabilities(SafariOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options), "options must not be null");
}
return options.ToCapabilities();
}
private void AddCustomSafariCommand(string commandName, string method, string resourcePath)
{
HttpCommandInfo commandInfoToAdd = new HttpCommandInfo(method, resourcePath);
this.CommandExecutor.TryAddCommand(commandName, commandInfoToAdd);
}
}
}
| C# | 5 | TamsilAmani/selenium | dotnet/src/webdriver/Safari/SafariDriver.cs | [
"Apache-2.0"
] |
@comment{-*- Dictionary: target:scribe/hem/hem; Mode: spell; Package: Hemlock -*-}
@chap[Introduction]
@hemlock is a text editor which follows in the tradition of @emacs
and the Lisp Machine editor ZWEI. In its basic form, @hemlock has almost
the same command set as ITS/TOPS-20 @emacs@foot[In this document, "Emacs"
refers to this, the original version, rather than to any of the large
numbers of text editors inspired by it which may go by the same name.],
and similar features such as multiple windows and extended commands, as
well as built in documentation features. The reader should bear in mind
that whenever some powerful feature of @hemlock is described, it has
probably been directly inspired by @emacs.
This manual describes @hemlock@comment{}'s commands and other user visible
features and then goes on to tell how to make simple customizations. For
complete documentation of the @hemlock primitives with which commands are
written, the @i[Hemlock Command Implementor's Manual] is also available.
@section[The Point and The Cursor]
@index[point]
@index[cursor]
The @i[point] is the current focus of editing activity. Text typed in by the
user is inserted at the point. Nearly all commands use the point as a
indication of what text to examine or modify. Textual positions in @hemlock
are between characters. This may seem a bit curious at first, but it is
necessary since text must be inserted between characters. Although the point
points between characters, it is sometimes said to point @i[at] a character, in
which case the character after the point is referred to.
The @i[cursor] is the visible indication of the current focus of attention: a
rectangular blotch under @windows, or the hardware cursor on a terminal. The
cursor is usually displayed on the character which is immediately after the
point, but it may be displayed in other places. Wherever the cursor is
displayed it indicates the current focus of attention. When input is being
prompted for in the echo area, the cursor is displayed where the input is to
go. Under @windows the cursor is only displayed when @hemlock is waiting
for input.
@section[Notation]
There are a number of notational conventions used in this manual which need
some explanation.
@subsection[Key-events]
@label[key-events]
@index[key-events, notation]
@index[bits, key-event]
@index[modifiers, key-event]
The canonical representation of editor input is a @i[key-event]. When you type
on the keyboard, @hemlock receives key-events. Key-events have names for their
basic form, and we refer to this name as a @i[keysym]. This manual displays
keysyms in a @bf[Bold] font. For example, @bf[a] and @bf[b] are the keys that
normally cause the editor to insert the characters @i[a] and @i[b].
Key-events have @i[modifiers] or @i[bits] indicating a special interpretation
of the root key-event. Although the keyboard places limitations on what
key-events you can actually type, @hemlock understands arbitrary combinations
of the following modifiers: @i[Control], @i[Meta], @i[Super], @i[Hyper],
@i[Shift], and @i[Lock]. This manual represents the bits in a key-event by
prefixing the keysym with combinations of @bf[C-], @bf[M-], @bf[S-], @bf[H-],
@bf[Shift-], and @bf[Lock]. For example, @bf[a] with both the control and meta
bits set appears as @bf[C-M-a]. In general, ignore the shift and lock
modifiers since this manual never talks about keysyms that explicitly have
these bits set; that is, it may talk about the key-event @bf[A], but it would
never mention @bf[Shift-a]. These are actually distinct key-events, but
typical input coercion turns presents @hemlock with the former, not the latter.
Key-event modifiers are totally independent of the keysym. This may be new to
you if you are used to thinking in terms of ASCII character codes. For
example, with key-events you can distinctly identify both uppercase and
lowercase keysyms with the control bit set; therefore, @bf[C-a] and @bf[C-A]
may have different meanings to @hemlock.
Some keysyms' names consist of more than a single character, and these usually
correspond to the legend on the keyboard. For example, some keyboards let you
enter @bf[Home], @bf[Return], @bf[F9], etc.
In addition to a keyboard, you may have a mouse or pointer device. Key-events
also represent this kind of input. For example, the down and up transitions of
the @i[left button] correspond to the @bf[Leftdown] and @bf[Leftup] keysyms.
See sections @ref[key-bindings], @ref[using-x], @ref[using-terminals]
@subsection[Commands]
@index[commands]@label[commands]Nearly everything that can be done in
@hemlock is done using a command. Since there are many things worth
doing, @hemlock provides many commands, currently nearly two hundred.
Most of this manual is a description of what commands exist, how they are
invoked, and what they do. This is the format of a command's
documentation:
@defcom[com "Sample Command", bind (C-M-q, C-`)]
@begin[quotation, facecode i, leftmargin 8ems, rightmargin 3.5ems,
below 0.8 lines]
This command's name is @hid[Sample Command], and it is bound to
@w(@bf(C-M-q)) and @bf[C-`], meaning that typing either of these will
invoke it. After this header comes a description of what the command does:
@end[quotation]
This command replaces all occurrences following the point of the string
"@f[Pascal]" with the string "@f[Lisp]". If a prefix argument is supplied,
then it is interpreted as the maximum number of occurrences to replace. If
the prefix argument is negative then the replacements are done backwards
from the point.
@comment<
@begin[quotation, facecode i, leftmargin 8ems, rightmargin 3.5ems,
above 0.8 lines, below 0.8 lines]
Toward the end of the description there may be information primarily of
interest to customizers and command implementors. If you don't understand
this information, don't worry, the writer probably forgot to speak English.
@end[quotation]
@b[Arguments:]
@begin[description]
@i[target]@\The string to replace with "@f[Lisp]".
@i[buffer]@\The buffer to do the replacement in. If this is @f[:all] then
the replacement is done in all buffers.
@end[description]>
@enddefcom
@subsection[Hemlock Variables]
@index[variables, hemlock]@hemlock variables supply a simple
customization mechanism by permitting commands to be parameterized. For
details see page @pageref[vars].
@defhvar[var "Sample Variable", val {36}]
@begin[quotation, facecode i, leftmargin 8ems, below 0.8 lines]
The name of this variable is @hid[Sample Variable] and its initial value is
36.
@end[quotation]
this variable sets a lower limit on the number of replacements that be done
by @hid[Sample Command]. If the prefix argument is supplied, and smaller
in absolute value than @hid[Sample Variable], then the user is prompted as
to whether that small a number of occurrences should be replaced, so as to
avoid a possibly disastrous error.
@enddefhvar
@section[Invoking Commands]
@index[invocation, command]
In order to get a command to do its thing, it must be invoked. The user can do
this two ways, by typing the @i[key] to which the command is @i[bound] or by
using an @i[extended command]. Commonly used commands are invoked via their
key bindings since they are faster to type, while less used commands are
invoked as extended commands since they are easier to remember.
@subsection[Key Bindings]
@index[bindings, key]
@index[key bindings]
@label[key-bindings]
A key is a sequence of key-events (see section @ref[key-events]) typed on the
keyboard, usually only one or two in length. Sections @ref[using-x] and
@ref[using-terminals] contain information on particular input devices.
When a command is bound to a key, typing the key causes @hemlock to invoke the
command. When the command completes its job, @hemlock returns to reading
another key, and this continually repeats.
Some commands read key-events interpreting them however each command desires.
When commands do this, key bindings have no effect, but you can usually abort
@hemlock whenever it is waiting for input by typing @binding[C-g] (see section
@ref[aborting]). You can usually find out what options are available by typing
@binding[C-_] or @binding[Home] (see section @ref[help]).
The user can easily rebind keys to different commands, bind new keys to
commands, or establish bindings for commands never bound before (see section
@ref[binding-keys]).
In addition to the key bindings explicitly listed with each command, there are
some implicit bindings created by using key translations@foot[Key translations
are documented in the @i[Hemlock Command Implementor's Manual].]. These
bindings are not displayed by documentation commands such as @hid[Where Is].
By default, there are only a few key translations. The modifier-prefix
characters @bf[C-^], @bf[Escape], @bf[C-z], or @bf[C-c] may be used when typing
keys to convert the following key-event to a control, meta, control-meta, or
hyper key-event. For example, @bf[C-x Escape b] invokes the same commands as
@bf[C-x M-b], and @bf[C-z u] is the same as @bf[C-M-u]. This allows user to
type more interesting keys on limited keyboards that lack control, meta, and
hyper keys.
@index[bit-prefix key-events]
@defhvar[var "Key Echo Delay", val {1.0}]
A key binding may be composed of several key-events, especially when you enter
it using modifier-prefix key-events. @hemlock provides feedback for partially
entered keys by displaying the typed key-events in the echo area. In order to
avoid excessive output and clearing of the echo area, this display is delayed
by @hid[Key Echo Delay] seconds. If this variable is set to @nil, then
@hemlock foregoes displaying initial subsequences of keys.
@enddefhvar
@subsection[Extended Commands]
@index[commands, extended]A command is invoked as an extended command by
typing its name to the @hid[Extended Command] command, which is invoked
using its key binding, @binding[M-x].
@defcom[com "Extended Command", bind {M-x}]
This command prompts in the echo area for the name of a command, and then
invokes that command. The prefix argument is passed through to the command
invoked. The command name need not be typed out in full, as long as enough
of its name is supplied to uniquely identify it. Completion is available
using @binding[Escape] and @binding[Space], and a list of possible completions
is given by @binding[Home] or @binding[C-_].
@enddefcom
@section[The Prefix Argument]
@index[prefix argument]The prefix argument is an integer argument which
may be supplied to a command. It is known as the prefix argument because
it is specified by invoking some prefix argument setting command
immediately before the command to be given the argument. The following
statements about the interpretation of the prefix argument are true:
@begin[itemize]
When it is meaningful, most commands interpret the prefix argument as a
repeat count, causing the same effect as invoking the command that many
times.
When it is meaningful, most commands that use the prefix argument interpret
a negative prefix argument as meaning the same thing as a positive
argument, but the action is done in the opposite direction.
Most commands treat the absence of a prefix argument as meaning the same
thing as a prefix argument of one.
Many commands ignore the prefix argument entirely.
Some commands do none of the above.
@end[itemize]
The following commands are used to set the prefix argument:
@defcom[com "Argument Digit", stuff (bound to all control or meta digits)]
Typing a number using this command sets the prefix argument to that number,
for example, typing @binding[M-1 M-2] sets the prefix argument to twelve.
@enddefcom
@defcom[com "Negative Argument", bind {M--}]
This command negates the prefix argument, or if there is none, sets it to
negative one. For example, typing @binding[M-- M-7] sets the prefix
argument to negative seven.
@enddefcom
@defcom[com "Universal Argument", bind {C-u}]
@defhvar1[var "Universal Argument Default", val {4}]
This command sets the prefix argument or multiplies it by four. If digits
are typed immediately afterward, they are echoed in the echo area, and the
prefix argument is set to the specified number. If no digits are typed
then the prefix argument is multiplied by four. @binding[C-u - 7] sets the
prefix argument to negative seven. @binding[C-u C-u] sets the prefix
argument to sixteen. @binding[M-4 M-2 C-u] sets the prefix argument to one
hundred and sixty-eight. @binding[C-u M-0] sets the prefix argument to
forty.
@hid[Universal Argument Default] determines the default value and multiplier
for the @hid[Universal Argument] command.
@enddefcom
@section[Modes]
@label[modes]@index[modes]A mode provides a way to change @hemlock@comment{}'s
behavior by specifying a modification to current key bindings, values of
variables, and other things. Modes are typically used to adjust @hemlock
to suit a particular editing task, e.g. @hid[Lisp] mode is used for editing
@llisp code.
Modes in @hemlock are not like modes in most text editors; @hemlock is really a
"modeless" editor. There are two ways that the @hemlock mode concept differs
from the conventional one:
@begin[enumerate]
Modes do not usually alter the environment in a very big way, i.e. replace
the set of commands bound with another totally disjoint one. When a mode
redefines what a key does, it is usually redefined to have a slightly
different meaning, rather than a totally different one. For this reason,
typing a given key does pretty much the same thing no matter what modes are
in effect. This property is the distinguishing characteristic of a
modeless editor.
Once the modes appropriate for editing a given file have been chosen, they
are seldom, if ever, changed. One of the advantages of modeless editors is
that time is not wasted changing modes.
@end[enumerate]
@index[major mode]A @i[major mode] is used to make some big change in the
editing environment. Language modes such as @hid[Pascal] mode are major
modes. A major mode is usually turned on by invoking the command
@i{mode-name}@hid[ Mode] as an extended command. There is only one major
mode present at a time. Turning on a major mode turns off the one that is
currently in effect.
@index[minor mode]A @i[minor mode] is used to make a small change in the
environment, such as automatically breaking lines if they get too long.
Unlike major modes, any number of minor modes may be present at once.
Ideally minor modes should do the "right thing" no matter what major and
minor modes are in effect, but this is may not be the case when key
bindings conflict.
Modes can be envisioned as switches, the major mode corresponding to one big
switch which is thrown into the correct position for the type of editing being
done, and each minor mode corresponding to an on-off switch which controls
whether a certain characteristic is present.
@defcom[com "Fundamental Mode"]
This command puts the current buffer into @hid[Fundamental] mode.
@hid[Fundamental] mode is the most basic major mode: it's the next best thing
to no mode at all.
@enddefcom
@section[Display Conventions]
@index[display conventions]
There are two ways that @hemlock displays information on the screen; one is
normal @i[buffer display], in which the text being edited is shown on the
screen, and the other is a @i[pop-up window].
@subsection[Pop-Up Windows]
@index[pop-up windows]
@index[random typeout]
@label[pop-up]
Some commands print out information that is of little permanent value, and
these commands use a @i[pop-up] window to display the information. It is known
as a @i[pop-up] window because it temporarily appears on the screen overlaying
text already displayed. Most commands of this nature can generate their output
quickly, but in case there is a lot of output, or the user wants to repeatedly
refer to the same output while editing, @hemlock saves the output in a buffer.
Different commands may use different buffers to save their output, and we refer
to these as @i[random typeout] buffers.
If the amount of output exceeds the size of the pop-up window, @Hemlock
displays the message @w<"@f[--More--]"> after each window full. The following
are valid responses to this prompt:
@Begin[Description]
@bf[Space], @bf[y]@\
Display the next window full of text.
@bf[Delete], @bf[Backspace], @bf[n]@\
Abort any further output.
@bf[Escape], @bf[!]@\
Remove the window and continue saving any further output in the buffer.
@bf[k]@\
This is the same as @bf[!] or @bf[escape], but @hemlock makes a normal window
over the pop-up window. This only works on bitmap devices.
@End[Description]
Any other input causes the system to abort using the key-event to determine
the next command to execute.
When the output is complete, @hemlock displays the string @w<"@f[--Flush--]">
in the pop-up window's modeline, indicating that the user may flush the
temporary display. Typing any of the key-events described above removes the
pop-up window, but typing @bf[k] still produces a window suitable for normal
editing. Any other input also flushes the display, but @hemlock uses the
key-event to determine the next command to invoke.
@defcom[com "Select Random Typeout Buffer", bind {H-t}]
This command makes the most recently used random typeout buffer the current
buffer in the current window.
@enddefcom
Random typeout buffers are always in @hid[Fundamental] mode.
@subsection[Buffer Display]
@index[buffer, display]
@index[display, buffer]
If a line of text is too long to fit within the screen width it is @i[wrapped],
with @hemlock displaying consecutive pieces of the text line on as many screen
lines as needed to hold the text. @hemlock indicates a wrapped line by placing
a line-wrap character in the last column of each screen line. Currently, the
line-wrap character is an exclamation point (@f[!]). It is possible for a line
to wrap off the bottom of the screen or on to the top.
@hemlock wraps screen lines when the line is completely full regardless of the
line-wrap character. Most editors insert the line-wrap character and wrap a
single character when a screen line would be full if the editor had avoided
wrapping the line. In this situation, @hemlock would leave the screen line
full. This means there are always at least two characters on the next screen
line if @hemlock wraps a line of display. When the cursor is at the end of a
line which is the full width of the screen, it is displayed in the last column,
since it cannot be displayed off the edge.
@hemlock displays most characters as themselves, but it treats some
specially:
@begin[itemize]
Tabs are treated as tabs, with eight character tab-stops.
Characters corresponding to ASCII control characters are printed as
@f[^]@i[char]; for example, a formfeed is @f[^L].
Characters with the most-significant bit on are displayed as
@f[<]@i[hex-code]@f[>]; for example, @f[<E2>].
@end[itemize]
Since a character may be displayed using more than one printing character,
there are some positions on the screen which are in the middle of a character.
When the cursor is on a character with a multiple-character representation,
@hemlock always displays the cursor on the first character.
@subsection[Recentering Windows]
@index[recentering windows]
@index[windows, recentering]
When redisplaying the current window, @hemlock makes sure the current point is
visible. This is the behavior you see when you are entering text near the
bottom of the window, and suddenly redisplay shifts your position to the
window's center.
Some buffers receive input from streams and other processes, and you might have
windows displaying these. However, if those windows are not the current
window, the output will run off the bottom of the windows, and you won't be
able to see the output as it appears in the buffers. You can change to a
window in which you want to track output and invoke the following command to
remedy this situation.
@defcom[com "Track Buffer Point"]
This command makes the current window track the buffer's point. This means
that each time Hemlock redisplays, it will make sure the buffer's point is
visible in the window. This is useful for windows that are not current and
that display buffer's that receive output from streams coming from other
processes.
@enddefcom
@subsection[Modelines]
@label[modelines]
@index[modeline]
A modeline is the line displayed at the bottom of each window where @hemlock
shows information about the buffer displayed in that window. Here is a typical
modeline:
@begin[programexample]
Hemlock USER: (Fundamental Fill) /usr/slisp/hemlock/user.mss
@end[programexample]
This tells us that the file associated with this buffer is
"@f[/usr/slisp/hemlock/user.mss]", and the @hid[Current Package] for Lisp
interaction commands is the @f["USER"] package. The modes currently present
are @hid[Fundamental] and @hid[Fill]; the major mode is always displayed first,
followed by any minor modes. If the buffer has no associated file, then the
buffer name will be present instead:
@begin[programexample]
Hemlock PLAY: (Lisp) Silly:
@end[programexample]
In this case, the buffer is named @hid[Silly] and is in @hid[Lisp] mode. The
user has set @hid[Current Package] for this buffer to @f["PLAY"].
@defhvar[var "Maximum Modeline Pathname Length", val {nil}]
This variable controls how much of a pathname @hemlock displays in a modeline.
Some distributed file systems can have very long pathnames which leads to the
more particular information in a pathname running off the end of a modeline.
When set, the system chops off leading directories until the name is less than
the integer value of this variable. Three dots, @f[...], indicate a truncated
name. The user can establish this variable buffer locally with the
@hid[Defhvar] command.
@enddefhvar
If the user has modified the buffer since the last time it was read from or
save to a file, then the modeline contains an asterisk (@f[*]) between the
modes list and the file or buffer name:
@begin[programexample]
Hemlock USER: (Fundamental Fill) * /usr/slisp/hemlock/user.mss
@end[programexample]
This serves as a reminder that the buffer should be saved eventually.
@index[status line]
There is a special modeline known as the @i[status line] which appears as the
@hid[Echo Area]'s modeline. @Hemlock and user code use this area to display
general information not particular to a buffer @dash recursive edits, whether
you just received mail, etc.
@section[Use with X Windows]
@label[using-x]
@index[X windows, use with]
You should use @hemlock on a workstation with a bitmap display and a windowing
system since @hemlock makes good use of a non-ASCII device, mouse, and the
extra modifier keys typically associated with workstations. This section
discusses using @hemlock under X windows, the only supported windowing system.
@subsection[Window Groups]
@index[window management]
@label[groups]
@hemlock manages windows under X in groups. This allows @hemlock to be more
sophisticated in its window management without being rude in the X paradigm of
screen usage. With window groups, @hemlock can ignore where the groups are,
but within a group, it can maintain the window creation and deletion behavior
users expect in editors without any interference from window managers.
Initially there are two groups, a main window and the @hid[Echo Area]. If you
keep a pop-up display, see section @ref[pop-up], @hemlock puts the window it
creates in its own group. There are commands for creating new groups.
@hemlock only links windows within a group for purposes of the @hid[Next
Window], @hid[Previous Window], and @hid[Delete Next Window] commands. To move
between groups, you must use the @hid[Point to Here] command bound to the
mouse.
Window manager commands can reshape and move groups on the screen.
@subsection[Event Translation]
@index[keyboard use under X]
@index[translation of keys under X]
Each X key event is translated into a canonical input representation, a
key-event. The X key event consists of a scan-code and modifier bits, and
these translate to an X keysym. This keysym and the modifier bits map to a
key-event.
If you type a key with a shift key held down, this typically maps to a distinct
X keysym. For example, the shift of @bf[3] is @bf[#], and these have different
X keysyms. Some keys map to the same X keysym regardless of the shift bit,
such as @bf[Tab], @bf[Space], @bf[Return], etc. When the X lock bit is on, the
system treats this as a caps-lock, only mapping keysyms for lowercase letters
to shifted keysyms.
The key-event has a keysym and a field of bits. The X keysyms map directly to
the key-event keysyms. There is a distinct mapping for each CLX modifier bit
to a key-event bit. This tends to eliminate shift and lock modifiers, so
key-events usually only have control, meta, hyper, and super bits on. Hyper
and super usually get turned on with prefix key-events that set them on the
following key-event, but you can turn certain keys on the keyboard into hyper
and super keys. See the X manuals and the @i[Hemlock Command Implementor's
Manual] for details.
The system also maps mouse input to key-events. Each mouse button has distinct
key-event keysyms for whether the user pressed or released it. For
convenience, @hemlock makes use of an odd property of converting mouse events
to key-events. If you enter a mouse event with the shift key held down,
@hemlock sees the key-event keysym for the mouse event, but the key-event has
the super bit turned on. For example, if you press the left button with the
shift key pressed, @hemlock sees @bf[S-Leftdown].
Note that with the two button mouse on the IBM RT PC, the only way to to send
@bf[Middledown] is to press both the left and right buttons simultaneously.
This is awkward, and it often confuses the X server. For this reason, the
commands bound to the middle button are also bound to the shifted left button,
@bf[S-Leftdown], which is much easier to type.
@subsection[Cut Buffer Commands]
@index[cutting]@index[pasting] These commands allow the X cut buffer to be
used from @hemlock . Although @hemlock can cut arbitrarily large regions,
a bug in the standard version 10 xterm prevents large regions from being
pasted into an xterm window.
@defcom[com "Region to Cut Buffer", bind {M-Insert}]
@defcom1[com "Insert Cut Buffer", bind {Insert}]
These commands manipulate the X cut buffer. @hid[Region to Cut Buffer] puts
the text in the region into the cut buffer. @hid[Insert Cut Buffer] inserts
the contents of the cut buffer at the point.
@enddefcom
@subsection[Redisplay and Screen Management]
These variables control a number of the characteristics of @hemlock bitmap
screen management.
@defhvar[var "Bell Style", val {:border-flash}]
@defhvar1[var "Beep Border Width", val {20}]
@hid[Bell Style] determines what beeps do in @hemlock. Acceptable values are
@kwd[border-flash], @kwd[feep], @kwd[border-flash-and-feep], @kwd[flash],
@kwd[flash-and-feep], and @nil (do nothing).
@hid[Beep Border Width] is the width in pixels of the border flashed by border
flash beep styles.
@enddefhvar
@defhvar[var "Reverse Video", val {nil}]
If this variable is true, then @hemlock paints white on black in window
bodies, black on white in modelines.
@enddefhvar
@defhvar[var "Thumb Bar Meter", val {t}]
If this variable is true, then windows will be created to be displayed with a
ruler in the bottom border of the window.
@enddefhvar
@defhvar[var "Set Window Autoraise", val {:echo-only}]
When true, changing the current window will automatically raise the new current
window. If the value is @kwd[echo-only], then only the echo area window will
be raised automatically upon becoming current.
@enddefhvar
@defhvar[var "Default Initial Window Width", val {80}]
@defhvar1[var "Default Initial Window Height", val {24}]
@defhvar1[var "Default Initial Window X"]
@defhvar1[var "Default Initial Window Y"]
@defhvar1[var "Default Window Height", val {24}]
@defhvar1[var "Default Window Width", val {80}]
@index[window placement]
@Hemlock uses the variables with "@hid[Initial]" in their names when it first
starts up to make its first window. The width and height are specified in
character units, but the x and y are specified in pixels. The other variables
determine the width and height for interactive window creation, such as making
a window with @comref[New Window].
@enddefhvar
@defhvar[var "Cursor Bitmap File", val {"library:hemlock.cursor"}]
This variable determines where the mouse cursor bitmap is read from when
@hemlock starts up. The mask is found by merging this name with "@f[.mask]".
This has to be a full pathname for the C routine.
@enddefhvar
@defhvar[var "Default Font"]
This variable holds the string name of the font to be used for normal text
display: buffer text, modelines, random typeout, etc. The font is loaded at
initialization time, so this variable must be set before entering @hemlock.
When @nil, the display type is used to choose a font.
@enddefhvar
@section[Use With Terminals]
@label[using-terminals]@index[terminals, use with] @hemlock can also be used
with ASCII terminals and terminal emulators. Capabilities that depend on
@windows (such as mouse commands) are not available, but nearly everything else
can be done.
@subsection[Terminal Initialization]
@index[terminal speed]
@index[speed, terminal]
@index[slow terminals]
@index[incremental redisplay]
For best redisplay performance, it is very important to set the terminal speed:
@lisp
stty 2400
@endlisp
Often when running @hemlock using TTY redisplay, Hemlock will actually be
talking to a PTY whose speed is initialized to infinity. In reality, the
terminal will be much slower, resulting in @hemlock@comment{}'s output getting way ahead
of the terminal. This prevents @hemlock from briefly stopping redisplay to
allow the terminal to catch up. See also @hvarref<Scroll Redraw Ratio>.
The terminal control sequences are obtained from the termcap database using the
normal Unix conventions. The @f["TERM"] environment variable holds the
terminal type. The @f["TERMCAP"] environment variable can be used to override
the default termcap database (in @f["/etc/termcap"]). The size of the terminal
can be altered from the termcap default through the use of:
@lisp
stty rows @i{height} columns @i{width}
@endlisp
@subsection[Terminal Input]
@index[ASCII keyboard translation]
@index[bit-prefix key-events]
@index[prefix key-events]
@index[key-event, prefix]
The most important limitation of a terminal is its input capabilities. On a
workstation with function keys and independent control, meta, and shift
modifiers, it is possible to type 800 or so distinct single keystrokes.
Although by default, @hemlock uses only a fraction of these combinations, there
are many more than the 128 key-events available in ASCII.
On a terminal, @hemlock attempts to translate ASCII control characters into the
most useful key-event:
@begin[itemize]
On a terminal, control does not compose with shift. If the control key is down
when you type a letter keys, the terminal always sends one code regardless of
whether the shift key is held. Since @hemlock primarily binds commands to
key-events with keysyms representing lowercase letters regardless of what bits
are set in the key-event, the system translates the ASCII control codes to a
keysym representing the appropriate lowercase characters. This keysym then
forms a key-event with the control bit set. Users can type @bf[C-c] followed
by an uppercase character to form a key-event with a keysym representing an
uppercase character and bits with the control bit set.
On a terminal, some of the named keys generate an ASCII control code. For
example, @f[Return] usually sends a @f[C-m]. The system translates these ASCII
codes to a key-event with an appropriate keysym instead of the keysym named by
the character which names the ASCII code. In the above example, typing the
@f[Return] key would generate a key-event with the @bf[Return] keysym and no
bits. It would NOT translate to a key-event with the @bf[m] keysym and the
control bit.
@end[itemize]
Since terminals have no meta key, you must use the @bf[Escape] and @bf[C-Z]
modifier-prefix key-events to invoke commands bound to key-events with the meta
bit or meta and control bits set. ASCII terminals cannot generate all
key-events which have the control bit on, so you can use the @bf[C-^]
modifier-prefix. The @bf[C-c] prefix sets the hyper bit on the next key-event
typed.
When running @hemlock from a terminal @f[^\] is the interrupt key-event.
Typing this will place you in the Lisp debugger.
When using a terminal, pop-up output windows cannot be retained after the
completion of the command.
@subsection[Terminal Redisplay]
Redisplay is substantially different on a terminal. @Hemlock uses different
algorithms, and different parameters control redisplay and screen management.
Terminal redisplay uses the Unix termcap database to find out how to use a
terminal. @hemlock is useful with terminals that lack capabilities for
inserting and deleting lines and characters, and some terminal emulators
implement these operations very inefficiently (such as xterm).
If you realize poor performance when scrolling, create a termcap entry that
excludes these capabilities.
@defhvar[var "Scroll Redraw Ratio", val {nil}]
This is a ratio of "inserted" lines to the size of a window. When this ratio
is exceeded, insert/delete line terminal optimization is aborted, and every
altered line is simply redrawn as efficiently as possible. For example,
setting this to 1/4 will cause scrolling commands to redraw the entire window
instead of moving the bottom two lines of the window to the top (typically 3/4
of the window is being deleted upward and inserted downward, hence a redraw);
however, commands like @hid[New Line] and @hid[Open Line] will still work
efficiently, inserting a line and moving the rest of the window's text
downward.
@enddefhvar
@section[The Echo Area]
@index[echo area]
@index[prompting]
The echo area is the region which occupies the bottom few lines on the screen.
It is used for two purposes: displaying brief messages to the user and
prompting.
When a command needs some information from the user, it requests it by
displaying a @i[prompt] in the echo area. The following is a typical prompt:
@begin[programexample]
Select Buffer: [hemlock-init.lisp /usr/foo/]
@end[programexample]
The general format of a prompt is a one or two word description of the input
requested, possibly followed by a @i[default] in brackets. The default is a
standard response to the prompt that @hemlock uses if you type @bf[Return]
without giving any other input.
There are four general kinds of prompts: @comment<Key prompts?>
@begin[description]
@i[key-event]@\
The response is a single key-event and no confirming @binding[Return] is
needed.
@i[keyword]@\
The response is a selection from one of a limited number of choices.
Completion is available using @binding[Space] and @binding[Escape], and you
only need to supply enough of the keyword to distinguish it from any other
choice. In some cases a keyword prompt accepts unknown input, indicating the
prompter should create a new entry. If this is the case, then you must enter
the keyword fully specified or completed using @binding[Escape]; this
distinguishes entering an old keyword from making a new keyword which is a
prefix of an old one since the system completes partial input automatically.
@i[file]@\
The response is the name of a file, which may have to exist. Unlike other
prompts, the default has some effect even after the user supplies some input:
the system @i[merges] the default with the input filename. See page
@pageref(merging) for a description of filename merging. @bf[Escape] and
@bf[Space] complete the input for a file parse.
@i[string]@\
The response is a string which must satisfy some property, such as being the
name of an existing file.
@end[description]
@index[history, echo area]
These key-events have special meanings when prompting:
@begin[description]
@binding[Return]@\
Confirm the current parse. If no input has been entered, then use the
default. If for some reason the input is unacceptable, @hemlock does two
things:
@Begin[enumerate]
beeps, if the variable @hid[Beep on Ambiguity] set, and
moves the point to the end of the first word requiring disambiguation.
@End[enumerate]
This allows you to add to the input before confirming the it again.
@binding[Home, C-_]@\
Print some sort of help message. If the parse is a keyword parse, then print
all the possible completions of the current input in a pop-up window.
@binding[Escape]@\
Attempt to complete the input to a keyword or file parse as far as possible,
beeping if the result is ambiguous. When the result is ambiguous, @hemlock
moves the point to the first ambiguous field, which may be the end of the
completed input.
@binding[Space]@\
In a keyword parse, attempt to complete the input up to the next space. This
is useful for completing the names of @hemlock commands and similar things
without beeping a lot, and you can continue entering fields while leaving
previous fields ambiguous. For example, you can invoke @hid[Forward Word] as
an extended command by typing @binding[M-X f Space w Return]. Each time the
user enters space, @Hemlock attempts to complete the current field and all
previous fields.
@binding[C-i, Tab]@\
In a string or keyword parse, insert the default so that it may be edited.
@binding[C-p]@\
Retrieve the text of the last string input from a history of echo area inputs.
Repeating this moves to successively earlier inputs.
@binding[C-n]@\
Go the other way in the echo area history.
@binding[C-q]@\
Quote the next key-event so that it is not interpreted as a command.
@end[description]
@defhvar[var "Ignore File Types"]
This variable is a list of file types (or extensions), represented as a string
without the dot, e.g. @f["fasl"]. Files having any of the specified types will
be considered nonexistent for completion purposes, making an unambiguous
completion more likely. The initial value contains most common binary and
output file types.
@enddefhvar
@section[Online Help]
@label[help]
@index[online help]
@index[documentation, hemlock]
@hemlock has a fairly good online documentation facility. You can get brief
documentation for every command, variable, character attribute, and key
by typing a key.
@defcom[com "Help", bind (Home, C-_)]
This command prompt for a key-event indicating one of a number of other
documentation commands. The following are valid responses:
@begin[description]
@bf[a]@\
List commands and other things whose names contain a specified keyword.
@bf[d]@\
Give the documentation and bindings for a specified command.
@bf[g]@\
Give the documentation for any @hemlock thing.
@bf[v]@\
Give the documentation for a @hemlock variable and its values.
@bf[c]@\
Give the documentation for a command bound to some key.
@bf[l]@\
List the last sixty key-events typed.
@bf[m]@\
Give the documentation for a mode followed by a short description of its
mode-specific bindings.
@bf[p]@\
Give the documentation and bindings for commands that have at least one
binding involving a mouse/pointer key-event.
@bf[w]@\
List all the key bindings for a specified command.
@bf[t]@\
Describe a @llisp object.
@binding[q]@\
Quit without doing anything.
@binding[Home, C-_, ?, h]@\
List all of the options and what they do.
@end[description]
@enddefcom
@defcom[com "Apropos", bind (Home a, C-_ a)]
This command prints brief documentation for all commands, variables, and
character attributes whose names match the input. This performs a prefix match
on each supplied word separately, intersecting the names in each word's result.
For example, giving @hid[Apropos] "@f[f m]" causes it to tersely describe
following commands and variables:
@Begin[Itemize]
@hid[Auto Fill Mode]
@hid[Fundamental Mode]
@hid[Mark Form]
@hid[Default Modeline Fields]
@hid[Fill Mode Hook]
@hid[Fundamental Mode Hook]
@End[Itemize]
Notice @hid[Mark Form] demonstrates that the "@f[f]" words may follow the
"@f[m]" order of the fields does not matter for @hid[Apropos].
The bindings of commands and values of variables are printed with the
documentation.
@enddefcom
@defcom[com "Describe Command", bind (Home d, C-_ d)]
This command prompts for a command and prints its full documentation and all
the keys bound to it.
@enddefcom
@defcom[com "Describe Key", bind (Home c, C-_ c, M-?)]
This command prints full documentation for the command which is bound to
the specified key in the current environment.
@enddefcom
@defcom[com "Describe Mode", bind (Home m, C-_ m)]
This command prints the documentation for a mode followed by a short
description of each of its mode-specific bindings.
@enddefcom
@defcom[com "Show Variable"]
@defcom1[com "Describe and Show Variable"]
@hid[Show Variable] prompts for the name of a variable and displays
the global value of the variable, the value local to the current buffer (if
any), and the value of the variable in all defined modes that have it as a
local variable. @hid[Describe and Show Variable] displays the variable's
documentation in addition to the values.
@enddefcom
@defcom[com "What Lossage", bind (Home l, C-_ l)]
This command displays the last sixty key-events typed. This can be useful
if, for example, you are curious what the command was that you typed by
accident.
@enddefcom
@defcom[com "Describe Pointer"]
This command displays the documentation and bindings for commands that have
some binding involving a mouse/pointer key-event. It will not show the
documentation for the @hid[Illegal] command regardless of whether it has a
pointer binding.
@enddefcom
@defcom[com "Where Is", bind (Home w, C-_ w)]
This command prompts for the name of a command and displays its key
bindings in a pop-up window. If a key binding is not global, the
environment in which it is available is displayed.
@enddefcom
@defcom[com "Generic Describe", bind (Home g, C-_ g)]
This command prints full documentation for any thing that has
documentation. It first prompts for the kind of thing to document, the
following options being available:
@begin[description]
@i[attribute]@\Describe a character attribute, given its name.
@i[command]@\Describe a command, given its name.
@i[key]@\Describe a command, given a key to which it is bound.
@i[variable]@\Describe a variable, given its name. This is the default.
@end[description]
@enddefcom
@section[Entering and Exiting]
@index[entering hemlock]@hemlock is entered by using the @clisp @f[ed]
function. Simply typing @f[(ed)] will enter @hemlock, leaving you in the state
that you were in when you left it. If @hemlock has never been entered before
then the current buffer will be @hid[Main]. The @f[-edit] command-line switch
may also be used to enter @hemlock: see page @pageref[edit-switch].
@f[ed] may optionally be given a file name or a symbol argument. Typing
@f[(ed @i[filename])] will cause the specified file to be read into @hemlock,
as though by @hid[Find File]. Typing @w<@f[(ed @i[symbol])]> will pretty-print
the definition of the symbol into a buffer whose name is obtained by adding
"@f[Edit ]" to the beginning of the symbol's name.
@defcom[com "Exit Hemlock", bind (C-c, C-x C-z)]
@defcom1[com "Pause Hemlock"]
@index[exiting hemlock]@hid[Exit Hemlock] exits @hemlock, returning @f[t].
@hid[Exit Hemlock] does not by default save modified buffers, or do
anything else that you might think it should do; it simply exits. At any time
after exiting you may reenter by typing @f[(ed)] to @llisp without losing
anything. Before you quit from @llisp using @f[(quit)], you should
save any modified files that you want to be saved.
@hid[Pause Hemlock] is similar, but it suspends the @llisp process and returns
control to the shell. When the process is resumed, it will still be running
@hemlock.
@enddefcom
@section[Helpful Information]
@label[aborting]
@index[aborting]
@index[undoing]
@index[error recovery]
This section contains assorted helpful information which may be useful in
staying out of trouble or getting out of trouble.
@begin[itemize]
It is possible to get some sort of help nearly everywhere by typing
@binding[Home] or @binding[C-_].
Various commands take over the keyboard and insist that you type the key-events
that they want as input. If you get in such a situation and want to get out,
you can usually do so by typing @bf[C-g] some small number of times. If this
fails you can try typing @binding[C-x C-z] to exit @hemlock and then "@f[(ed)]"
to re-enter it.
Before you quit, make sure you have saved all your changes. @binding[C-u C-x
C-b] will display a list of all modified buffers. If you exit using @bf[C-x
M-z], then @hemlock will save all modified buffers with associated files.
If you lose changes to a file due to a crash or accidental failure to save,
look for backup ("@i[file]@f[.BAK]") or checkpoint ("@i[file]@f[.CKP]") files
in the same directory where the file was.
If the screen changes unexpectedly, you may have accidentally typed an
incorrect command. Use @binding[Home l] to see what it was. If you are
not familiar with the command, use @binding[Home c] to see what it is so that
you know what damage has been done. Many interesting commands can be found
in this fashion. This is an example of the much-underrated learning
technique known as "Learning by serendipitous malcoordination". Who would
ever think of looking for a command that deletes all files in the current
directory?
If you accidentally type a "killing" command such as @binding[C-w], you can
get the lost text back using @binding[C-y]. The @hid[Undo] command is also
useful for recovering from this sort of problem.
@end[itemize]
@defhvar[var "Region Query Size", val {30}]
@index[large region]
Various commands ask for confirmation before modifying a region containing more
than this number of lines. If this is @nil, then these commands refrain from
asking, no matter how large the region is.
@enddefhvar
@defcom[com "Undo"]
This command undoes the last major modification. Killing commands and some
other commands save information about their modifications, so accidental uses
may be retracted. This command displays the name of the operation to be undone
and asks for confirmation. If the affected text has been modified between the
invocations of @hid[Undo] and the command to be undone, then the result may be
somewhat incorrect but useful. Often @hid[Undo] itself can be undone by
invoking it again.
@enddefcom
@section[Recursive Edits]
@label[recursive-edits]
@index[recursive edits]
Some sophisticated commands, such as @hid[Query Replace], can place you in a
@i[recursive edit]. A recursive edit is simply a recursive invocation of
@hemlock done within a command. A recursive edit is useful because it allows
arbitrary editing to be done during the execution of a command without losing
any state that the command might have. When the user exits a recursive edit,
the command that entered it proceeds as though nothing happened. @Hemlock
notes recursive edits in the @hid[Echo Area] modeline, or status line. A
counter reflects the number of pending recursive edits.
@defcom[com "Exit Recursive Edit", bind (C-M-z)]
This command exits the current recursive edit, returning @nil. If invoked when
not in a recursive edit, then this signals an user error.
@enddefcom
@defcom[com "Abort Recursive Edit", bind (@bf<C-]>)]
This command causes the command which invoked the recursive edit to get an
error. If not in a recursive edit, this signals an user error.
@enddefcom
@section[User Errors]
@index[beeping]
@index[errors, user]
When in the course of editing, @hemlock is unable to do what it thinks you want
to do, then it brings this to your attention by a beep or a screen flash
(possibly accompanied by an explanatory echo area message such as @w<"@f[No
next line.]">.) Although the exact attention-getting mechanism may vary on the
output device and variable settings, this is always called @i[beeping].
Whatever the circumstances, you had best try something else since @hemlock,
being far more stupid than you, is far more stubborn. @hemlock is an
extensible editor, so it is always possible to change the command that
complained to do what you wanted it to do.
@section[Internal Errors]
@index[errors, internal]A message of this form may appear in the echo
area, accompanied by a beep:
@begin[programexample]
Internal error:
Wrong type argument, NIL, should have been of type SIMPLE-VECTOR.
@end[programexample]
If the error message is a file related error such as the following, then
you have probably done something illegal which @hemlock did not catch,
but was detected by the file system:
@begin[programexample]
Internal error:
No access to "/lisp2/emacs/teco.mid"
@end[programexample]
Otherwise, you have found a bug. Try to avoid the behavior that resulted
in the error and report the problem to your system maintainer. Since @llisp
has fairly robust error recovery mechanisms, probably no damage has been
done.
If a truly abominable error from which @hemlock cannot recover occurs,
then you will be thrown into the @llisp debugger. At this point it would be
a good idea to save any changes with @f[save-all-buffers] and then start
a new @llisp.
@index[save-all-buffers, function]The @llisp function @f[save-all-buffers] may
be used to save modified buffers in a seriously broken @hemlock. To use this,
type "@f[(save-all-buffers)]" to the top-level ("@f[* ]") or debugger
("@f<1] >") prompt and confirm saving of each buffer that should be saved.
Since this function will prompt in the "@f[Lisp]" window, it isn't very useful
when called inside of @hemlock.
| CartoCSS | 5 | digikar99/ccl | cocoa-ide/hemlock/doc/user/intro.mss | [
"Apache-2.0"
] |
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 459.7 459.7"><path d="M392.4 67.3C349 24 291.2 0 229.9 0S110.7 24 67.3 67.3 0 168.5 0 230s24 119 67.3 162.5c43.4 43.4 101.2 67.3 162.6 67.3s119-23.9 162.5-67.3a228.3 228.3 0 0 0 67.3-162.5c0-61.4-24-119.2-67.3-162.6zM319.6 309c19.3-21.9 29.9-49.7 29.9-79.1 0-29.5-10.6-57.3-30-79.2L387 83.3c37.3 40 57.7 91.7 57.7 146.6S424.3 336.5 387 376.4zm-163.7-5.1c-17.5-17.5-28-40.1-30.3-64.5a46.7 46.7 0 0 0 47.4-5.6 46.3 46.3 0 0 0 56.9 0 46.3 46.3 0 0 0 56.8 0 46.3 46.3 0 0 0 47.4 5.6c-2.2 24.4-12.8 47-30.2 64.5a104 104 0 0 1-74 30.6 104 104 0 0 1-74-30.6zm0-148a104 104 0 0 1 74-30.7 104 104 0 0 1 74 30.7c17.9 17.9 28.5 41.1 30.3 66.1a31.6 31.6 0 0 1-42-3.4 7.5 7.5 0 0 0-10.9 0 31.5 31.5 0 0 1-46 0 7.5 7.5 0 0 0-10.9 0c-6 6.3-14.2 9.8-23 9.8-8.7 0-16.9-3.5-23-9.8a7.5 7.5 0 0 0-10.9 0 31.5 31.5 0 0 1-42 3.4c1.8-25 12.4-48.2 30.4-66.1zm220.5-83.2L309 140.1a118.8 118.8 0 0 0-79.1-29.9c-29.5 0-57.3 10.6-79.2 30L83.3 72.6C123.3 35.4 175 15 230 15c54.8 0 106.6 20.5 146.5 57.7zM15 230c0-55 20.5-106.7 57.7-146.6l67.4 67.4c-19.3 21.9-29.9 49.7-29.9 79.2s10.6 57.2 30 79l-67.5 67.5A213.3 213.3 0 0 1 15 229.9zm68.3 157l67.4-67.3c21.9 19.3 49.7 29.9 79.2 29.9 29.4 0 57.2-10.6 79-30l67.5 67.5a213.3 213.3 0 0 1-146.5 57.7A213.3 213.3 0 0 1 83.3 387z"/><path d="M235.5 58.5c33.3 1 65.2 11.6 92.3 30.6a7.5 7.5 0 0 0 10.5-1.9c2.4-3.4 1.5-8-1.9-10.4A185.7 185.7 0 0 0 236 43.5a7.5 7.5 0 0 0-.5 15zM395 143a186 186 0 0 0-9-15.2 7.5 7.5 0 1 0-12.6 8.2c3 4.5 5.8 9.2 8.3 14a7.5 7.5 0 1 0 13.3-7zM409 178a7.5 7.5 0 1 0-14.4 4.2c8 27.8 8.9 57.5 2.5 85.7a7.5 7.5 0 1 0 14.6 3.3c7-30.7 6-62.9-2.6-93.1zM258.3 292.4c12.9 0 24.9-5.2 33.8-14.5a7.5 7.5 0 1 0-10.8-10.4 31.5 31.5 0 0 1-46 0 7.5 7.5 0 0 0-10.9 0 31.5 31.5 0 0 1-46 0 7.5 7.5 0 1 0-10.8 10.4 46.3 46.3 0 0 0 62.3 4.8c8 6.3 18 9.7 28.4 9.7z"/></svg> | SVG | 1 | omidtajik/material-ui | docs/public/static/themes/onepirate/producBuoy.svg | [
"MIT"
] |
# Literal as subject
"abc" <http://www.w3.org/2013/TurtleTests/p> <http://www.w3.org/2013/TurtleTests/p> .
| Turtle | 1 | joshrose/audacity | lib-src/lv2/serd/tests/TurtleTests/turtle-syntax-bad-struct-14.ttl | [
"CC-BY-3.0"
] |
Setup:
$ . $TESTDIR/setup.sh
$ echo 'blah abc def' > blah1.txt
$ echo 'abc blah def' > blah2.txt
$ echo 'abc def blah' > blah3.txt
$ echo 'abcblah def' > blah4.txt
$ echo 'abc blahdef' >> blah4.txt
$ echo 'blahx blah' > blah5.txt
$ echo 'abcblah blah blah' > blah6.txt
Match a word of the beginning:
$ ag -wF --column 'blah' blah1.txt
1:1:blah abc def
Match a middle word:
$ ag -wF --column 'blah' blah2.txt
1:5:abc blah def
Match a last word:
$ ag -wF --column 'blah' blah3.txt
1:9:abc def blah
No match:
$ ag -wF --column 'blah' blah4.txt
[1]
Match:
$ ag -wF --column 'blah' blah5.txt
1:7:blahx blah
Case of a word repeating the same part:
$ ag -wF --column 'blah blah' blah6.txt
1:9:abcblah blah blah
| Perl | 4 | kknives/the_silver_searcher | tests/literal_word_regexp.t | [
"Apache-2.0"
] |
namespace Avalonia.OpenGL
{
public enum GlProfileType
{
OpenGL,
OpenGLES
}
public struct GlVersion
{
public GlProfileType Type { get; }
public int Major { get; }
public int Minor { get; }
public GlVersion(GlProfileType type, int major, int minor)
{
Type = type;
Major = major;
Minor = minor;
}
}
}
| C# | 4 | jangernert/Avalonia | src/Avalonia.OpenGL/GlVersion.cs | [
"MIT"
] |
; Alert dialog callable from the shell.
;
; Copyright (c) 2011 Martin Hedenfalk <[email protected]>
;
; Permission to use, copy, modify, and distribute this software for any
; purpose with or without fee is hereby granted, provided that the above
; copyright notice and this permission notice appear in all copies.
;
; THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
; WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
; MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
; ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
; WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
; ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
; OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
(NSApp activateIgnoringOtherApps:YES)
(unless (defined buttonTitles)
(set buttonTitles (NSArray arrayWithList:'("OK" "Cancel"))))
(unless (defined messageTitle)
(set messageTitle "Something happened"))
(unless (defined informativeText)
(set informativeText "It was unexpected"))
(unless (defined alertStyle)
(set alertStyle "informational"))
(set alert ((NSAlert alloc) init))
(buttonTitles each: (do (title)
(alert addButtonWithTitle:title)))
(alert setMessageText:messageTitle)
(alert setInformativeText:informativeText)
(case alertStyle
("warning" (alert setAlertStyle:NSWarningAlertStyle))
("critical" (alert setAlertStyle:NSCriticalAlertStyle))
(else (alert setAlertStyle:NSInformationalAlertStyle)))
(shellCommand exitWithObject:(- (alert runModal) 1000))
| Nu | 3 | girvo/vico | Support/lib/nu/alert.nu | [
"Unlicense"
] |
insert into t (id) values
(0), (1), (2), (3), (4), (5), (6), (7), (8), (9),
(10), (11), (12), (13), (14), (15), (16), (17), (18), (19),
(20), (21), (22), (23), (24), (25), (26), (27), (28), (29),
(30), (31), (32), (33), (34), (35), (36), (37), (38), (39),
(40), (41), (42), (43), (44), (45), (46), (47), (48), (49),
(50), (51), (52), (53), (54), (55), (56), (57), (58), (59),
(60), (61), (62), (63), (64), (65), (66), (67), (68), (69),
(70), (71), (72), (73), (74), (75), (76), (77), (78), (79),
(80), (81), (82), (83), (84), (85), (86), (87), (88), (89),
(90), (91), (92), (93), (94), (95), (96), (97), (98), (99),
(100), (101), (102), (103), (104), (105), (106), (107), (108), (109),
(110), (111), (112), (113), (114), (115), (116), (117), (118), (119),
(120), (121), (122), (123), (124), (125), (126), (127), (128), (129),
(130), (131), (132), (133), (134), (135), (136), (137), (138), (139),
(140), (141), (142), (143), (144), (145), (146), (147), (148), (149),
(150), (151), (152), (153), (154), (155), (156), (157), (158), (159),
(160), (161), (162), (163), (164), (165), (166), (167), (168), (169),
(170), (171), (172), (173), (174), (175), (176), (177), (178), (179),
(180), (181), (182), (183), (184), (185), (186), (187), (188), (189),
(190), (191), (192), (193), (194), (195), (196), (197), (198), (199),
(200), (201), (202), (203), (204), (205), (206), (207), (208), (209),
(210), (211), (212), (213), (214), (215), (216), (217), (218), (219),
(220), (221), (222), (223), (224), (225), (226), (227), (228), (229),
(230), (231), (232), (233), (234), (235), (236), (237), (238), (239),
(240), (241), (242), (243), (244), (245), (246), (247), (248), (249),
(250), (251), (252), (253), (254), (255), (256), (257), (258), (259),
(260), (261), (262), (263), (264), (265), (266), (267), (268), (269),
(270), (271), (272), (273), (274), (275), (276), (277), (278), (279),
(280), (281), (282), (283), (284), (285), (286), (287), (288), (289),
(290), (291), (292), (293), (294), (295), (296), (297), (298), (299),
(300), (301), (302), (303), (304), (305), (306), (307), (308), (309),
(310), (311), (312), (313), (314), (315), (316), (317), (318), (319),
(320), (321), (322), (323), (324), (325), (326), (327), (328), (329),
(330), (331), (332), (333), (334), (335), (336), (337), (338), (339),
(340), (341), (342), (343), (344), (345), (346), (347), (348), (349),
(350), (351), (352), (353), (354), (355), (356), (357), (358), (359),
(360), (361), (362), (363), (364), (365), (366), (367), (368), (369),
(370), (371), (372), (373), (374), (375), (376), (377), (378), (379),
(380), (381), (382), (383), (384), (385), (386), (387), (388), (389),
(390), (391), (392), (393), (394), (395), (396), (397), (398), (399),
(400), (401), (402), (403), (404), (405), (406), (407), (408), (409),
(410), (411), (412), (413), (414), (415), (416), (417), (418), (419),
(420), (421), (422), (423), (424), (425), (426), (427), (428), (429),
(430), (431), (432), (433), (434), (435), (436), (437), (438), (439),
(440), (441), (442), (443), (444), (445), (446), (447), (448), (449),
(450), (451), (452), (453), (454), (455), (456), (457), (458), (459),
(460), (461), (462), (463), (464), (465), (466), (467), (468), (469),
(470), (471), (472), (473), (474), (475), (476), (477), (478), (479),
(480), (481), (482), (483), (484), (485), (486), (487), (488), (489),
(490), (491), (492), (493), (494), (495), (496), (497), (498), (499);
| SQL | 1 | cuishuang/tidb | br/tests/lightning_disk_quota/data/disk_quota.t.0.sql | [
"Apache-2.0"
] |
/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
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.
==============================================================================*/
#ifndef TENSORFLOW_LITE_KERNELS_SHIM_STATUS_MACROS_H_
#define TENSORFLOW_LITE_KERNELS_SHIM_STATUS_MACROS_H_
#include "absl/status/status.h"
// A few macros to help with propagating status.
// They are mainly adapted from the ones in tensorflow/core/platform/errors.h
// and tensorflow/core/platform/statusor.h but these files come with many
// transitive deps which can be too much for TFLite use cases. If these type of
// macros end up in `absl` we can replace them with those.
// The macros are prefixed with SH_ to avoid name collision.
namespace tflite {
namespace shim {
template <typename... Args>
void AppendToMessage(::absl::Status* status, Args... args) {
*status = ::absl::Status(status->code(),
::absl::StrCat(status->message(), "\n\t", args...));
}
} // namespace shim
} // namespace tflite
// Propagates error up the stack and appends to the error message.
#define SH_RETURN_WITH_CONTEXT_IF_ERROR(expr, ...) \
do { \
::absl::Status _status = (expr); \
if (!_status.ok()) { \
::tflite::shim::AppendToMessage(&_status, __VA_ARGS__); \
return _status; \
} \
} while (0)
// Propages the error up the stack.
// This can't be merged with the SH_RETURN_WITH_CONTEXT_IF_ERROR unless some
// overly clever/unreadable macro magic is used.
#define SH_RETURN_IF_ERROR(...) \
do { \
::absl::Status _status = (__VA_ARGS__); \
if (!_status.ok()) return _status; \
} while (0)
// Internal helper for concatenating macro values.
#define SH_STATUS_MACROS_CONCAT_NAME_INNER(x, y) x##y
#define SH_STATUS_MACROS_CONCAT_NAME(x, y) \
SH_STATUS_MACROS_CONCAT_NAME_INNER(x, y)
// Assigns an expression to lhs or propagates the error up.
#define SH_ASSIGN_OR_RETURN(lhs, rexpr) \
SH_ASSIGN_OR_RETURN_IMPL( \
SH_STATUS_MACROS_CONCAT_NAME(statusor, __COUNTER__), lhs, rexpr)
#define SH_ASSIGN_OR_RETURN_IMPL(statusor, lhs, rexpr) \
auto statusor = (rexpr); \
if (!statusor.ok()) return statusor.status(); \
lhs = std::move(statusor.value())
#endif // TENSORFLOW_LITE_KERNELS_SHIM_STATUS_MACROS_H_
| C | 4 | EricRemmerswaal/tensorflow | tensorflow/lite/kernels/shim/status_macros.h | [
"Apache-2.0"
] |
package com.baeldung.startup;
import org.springframework.stereotype.Component;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
@Component
public class ResourceInitializer {
ResourceInitializer() throws Exception {
// simulate resource init with random delay of a few seconds
int randomDelay = ThreadLocalRandom.current().nextInt(5, 9);
TimeUnit.SECONDS.sleep(randomDelay);
}
}
| Java | 4 | DBatOWL/tutorials | spring-boot-modules/spring-boot-actuator/src/main/java/com/baeldung/startup/ResourceInitializer.java | [
"MIT"
] |
default
{
state_entry()
{
float r = llFrand(2) - 1.0;
llOwnerSay("The arccosine of " + (string)r + " is " + llAcos(r));
}
}
| LSL | 4 | MandarinkaTasty/OpenSim | bin/assets/ScriptsAssetSet/llAcos.lsl | [
"BSD-3-Clause"
] |
#pragma once
#include "envoy/upstream/upstream.h"
#include "source/extensions/filters/network/thrift_proxy/thrift.h"
namespace Envoy {
namespace Extensions {
namespace NetworkFilters {
namespace ThriftProxy {
/**
* Extends Upstream::ProtocolOptionsConfig with Thrift-specific cluster options.
*/
class ProtocolOptionsConfig : public Upstream::ProtocolOptionsConfig {
public:
~ProtocolOptionsConfig() override = default;
virtual TransportType transport(TransportType downstream_transport) const PURE;
virtual ProtocolType protocol(ProtocolType downstream_protocol) const PURE;
};
} // namespace ThriftProxy
} // namespace NetworkFilters
} // namespace Extensions
} // namespace Envoy
| C | 4 | dcillera/envoy | source/extensions/filters/network/thrift_proxy/protocol_options_config.h | [
"Apache-2.0"
] |
--TEST--
bcadd() incorrect argument count
--EXTENSIONS--
bcmath
--INI--
bcmath.scale=-2
--FILE--
<?php
echo bcadd("-4.27", "7.3");
?>
--EXPECT--
3
| PHP | 3 | NathanFreeman/php-src | ext/bcmath/tests/bcscale_variation002.phpt | [
"PHP-3.01"
] |
#include <stdlib.h>
int* foo() {
int* y;
y = (int*) malloc( sizeof( int ));
return y;
}
int main( int argc, char** argv ) {
// error, did not free or assign memory malloc-d by foo
foo();
return 0;
}
| Unified Parallel C | 3 | maurizioabba/rose | projects/RTED/tests/UPC/simple/test.upc | [
"BSD-3-Clause"
] |
body {
background: #181818;
}
/*
* Auth
*/
.authcontainer {
max-width: 420px;
margin: 96px auto;
}
.authcontainer a {
color: #8b5cf6 !important;
}
.authcontainer button[type='submit'] {
background: #8b5cf6 !important;
}
.authcontainer input:focus {
border-color: #8b5cf6 !important;
}
.authcontainer .sbui-typography-text-danger {
top: 3px !important;
position: absolute !important;
}
| CSS | 4 | ProPiloty/supabase | examples/nextjs-auth-tailwind/styles/globals.css | [
"Apache-2.0"
] |
many maybe
shh 1
wow
| Dogescript | 0 | joeratt/dogescript | test/spec/operators/maybe/source.djs | [
"MIT"
] |
import * as TodoTaskController from 'TodoTask.js';
import TodoInput from '../Controls/TodoInput';
define TodoTask extends TodoTaskController {
let TaskView as (.view) {
input.toggle type=checkbox {
dualbind
value = completed
// emit signal when INPUTs state changes via user input
x-signal = 'dom: taskChanged'
;
}
label > '~[bind:title]';
button.destroy x-tap = 'taskRemoved';
}
let TaskEdit as (input.edit preserve) extends TodoInput {
dualbind
value = 'title'
dom-slot = submit
// emit `taskChange` signal each time model is changed
// via user input
x-signal = 'dom: taskChanged'
;
}
/* `+visible` is same as `+if` with one difference:
* by falsy condition it still renders the nodes (with display:none)
* and `+if` first renders only when the condition becomes true.
*/
+visible ($._isVisible(completed, action)) {
li
.~[bind:completed ? 'completed']
.~[bind:state]
// emit `edit` on `dblclick` event
x-signal = 'dblclick: edit'
{
TaskView;
TaskEdit;
}
}
}
| Mask | 5 | richorrichard/todomvc | examples/atmajs/js/Todos/TodoTask.mask | [
"MIT"
] |
.root
--dropdown-text-color: var(--color-front)
font: inherit
background: transparent
border: none
appearance: none
background-color: var(--color-back)
background-image: url('data:image/svg+xml;charset=US-ASCII,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22292.4%22%20height%3D%22292.4%22%3E%3Cpath%20fill%3D%22%23929e9b%22%20d%3D%22M287%2069.4a17.6%2017.6%200%200%200-13-5.4H18.4c-5%200-9.3%201.8-12.9%205.4A17.6%2017.6%200%200%200%200%2082.2c0%205%201.8%209.3%205.4%2012.9l128%20127.9c3.6%203.6%207.8%205.4%2012.8%205.4s9.2-1.8%2012.8-5.4L287%2095c3.5-3.5%205.4-7.8%205.4-12.8%200-5-1.9-9.2-5.5-12.8z%22%2F%3E%3C%2Fsvg%3E')
background-repeat: no-repeat
background-position: right 0.7em top 50%
background-size: 0.5em auto
padding: 0 1.4em 0 0.5em
&:-moz-focusring
text-shadow: 0 0 0 var(--dropdown-text-color)
color: transparent
| Sass | 3 | snosrap/spaCy | website/src/styles/dropdown.module.sass | [
"MIT"
] |
//
// Copyright (c) 2006, Brian Frank and Andy Frank
// Licensed under the Academic Free License version 3.0
//
// History:
// 3 Nov 06 Brian Frank Creation
//
**
** Depend models a dependency as a pod name and a version
** constraint. Convention for Fantom pods is a four part
** version format of 'major.minor.build.patch'.
**
** The string format for Depend:
**
** <depend> := <name> space <version>
** <version> := <digits> ["." <digits>]*
** <digits> := <digit> [<digits>]*
** <digit> := "0" - "9"
**
** Examples:
** "foo 1.2" Any version of foo 1.2 with any build or patch number
** "foo 1.2.64" Any version of foo 1.2.64 with any patch number
**
@Serializable { simple = true }
final const class Depend
{
private const Str str
//////////////////////////////////////////////////////////////////////////
// Construction
//////////////////////////////////////////////////////////////////////////
**
** Parse the string according into a dependency. See class
** header for specification of the format. If invalid format
** and checked is false return null, otherwise throw ParseErr.
**
static new fromStr(Str s) {
pos := s.find(" ")
if (pos <= 0 || pos >= s.size-1) {
throw ParseErr("Invalid Depend :$s")
}
name := s[0..<pos]
end := s.find("+")
if (end == -1) end = s.find(",")
ver := Version.fromStr(s[pos+1..end])
return privateMake(name, ver)
}
**
** Private constructor
**
private new privateMake(Str name, Version ver) {
this.name = name
this.version = ver
this.str = "$name $version"
}
//////////////////////////////////////////////////////////////////////////
// Identity
//////////////////////////////////////////////////////////////////////////
**
** Two Depends are equal if they have same normalized string representation.
**
override Bool equals(Obj? that) {
if (that isnot Depend) return false
return str == ((Depend)that).str
}
**
** Return a hash code based on the normalized string representation.
**
override Int hash() { str.hash }
**
** Get the normalized string format of this dependency. Normalized
** dependency strings do not contain any optional spaces. See class
** header for specification of the format.
**
override Str toStr() { str }
**
** Get the pod name of the dependency.
**
const Str name
//////////////////////////////////////////////////////////////////////////
// Version Constraints
//////////////////////////////////////////////////////////////////////////
**
** Get the version constraint
**
const Version version
**
** Return if the specified version is a match against
** this dependency's constraints. See class header for
** matching rules.
**
Bool match(Version v) {
if (version.segments.size > v.segments.size) {
return false
}
for (i:=0; i<version.segments.size; ++i) {
if (version.segments[i] != v.segments[i]) {
return false
}
}
return true
}
}
| Fantom | 5 | fanx-dev/fanx | library/std/fan/reflect/Depend.fan | [
"AFL-3.0"
] |
// Renderer side modules, please sort alphabetically.
export const rendererModuleList: ElectronInternal.ModuleEntry[] = [
{ name: 'contextBridge', loader: () => require('./context-bridge') },
{ name: 'crashReporter', loader: () => require('./crash-reporter') },
{ name: 'ipcRenderer', loader: () => require('./ipc-renderer') },
{ name: 'webFrame', loader: () => require('./web-frame') }
];
| TypeScript | 4 | TarunavBA/electron | lib/renderer/api/module-list.ts | [
"MIT"
] |
INCLUDEPATH += $$PWD/include/
HEADERS += $$PWD/include/tabulate/cell.hpp \
$$PWD/include/tabulate/color.hpp \
$$PWD/include/tabulate/column.hpp \
$$PWD/include/tabulate/column_format.hpp \
$$PWD/include/tabulate/exporter.hpp \
$$PWD/include/tabulate/font_align.hpp \
$$PWD/include/tabulate/font_style.hpp \
$$PWD/include/tabulate/format.hpp \
$$PWD/include/tabulate/latex_exporter.hpp \
$$PWD/include/tabulate/markdown_exporter.hpp \
$$PWD/include/tabulate/asciidoc_exporter.hpp \
$$PWD/include/tabulate/printer.hpp \
$$PWD/include/tabulate/row.hpp \
$$PWD/include/tabulate/table.hpp \
$$PWD/include/tabulate/table_internal.hpp \
$$PWD/include/tabulate/term_color.hpp \
$$PWD/include/tabulate/utf8.hpp \ | QMake | 1 | byronhe/tabulate | tabulate.pri | [
"BSL-1.0",
"BSD-3-Clause",
"MIT"
] |
scriptname SKI_ConfigBase extends SKI_QuestBase
;##################################################################################################
; API Version: 3
;##################################################################################################
;
; Base script for custom config menus.
;
; This file contains the public interface of SKI_ConfigBase so you're able to extend it.
; For documentation, see https://github.com/schlangster/skyui/wiki/MCM-API-Reference.
;
; DO NOT MODIFY THIS SCRIPT!
; DO NOT RECOMPILE THIS SCRIPT!
;
;##################################################################################################
; CONSTANTS ---------------------------------------------------------------------------------------
int property OPTION_FLAG_NONE = 0x00 autoReadonly
int property OPTION_FLAG_DISABLED = 0x01 autoReadonly
int property OPTION_FLAG_HIDDEN = 0x02 autoReadonly ; Version 3
int property OPTION_FLAG_WITH_UNMAP = 0x04 autoReadonly ; Version 3
int property LEFT_TO_RIGHT = 1 autoReadonly
int property TOP_TO_BOTTOM = 2 autoReadonly
; PROPERTIES ------------------------------------------------------------------------- Version 1 --
string property ModName auto
string[] property Pages auto
string property CurrentPage
string function get()
Guard()
return ""
endFunction
endProperty
; EVENTS ----------------------------------------------------------------------------- Version 1 --
event OnConfigInit()
{Called when this config menu is initialized}
Guard()
endEvent
event OnConfigRegister()
{Called when this config menu registered at the control panel}
Guard()
endEvent
event OnConfigOpen()
{Called when this config menu is opened}
Guard()
endEvent
event OnConfigClose()
{Called when this config menu is closed}
Guard()
endEvent
event OnVersionUpdate(int a_version)
{Called when a version update of this script has been detected}
Guard()
endEvent
event OnPageReset(string a_page)
{Called when a new page is selected, including the initial empty page}
Guard()
endEvent
event OnOptionHighlight(int a_option)
{Called when highlighting an option}
Guard()
endEvent
event OnOptionSelect(int a_option)
{Called when a non-interactive option has been selected}
Guard()
endEvent
event OnOptionDefault(int a_option)
{Called when resetting an option to its default value}
Guard()
endEvent
event OnOptionSliderOpen(int a_option)
{Called when a slider option has been selected}
Guard()
endEvent
event OnOptionSliderAccept(int a_option, float a_value)
{Called when a new slider value has been accepted}
Guard()
endEvent
event OnOptionMenuOpen(int a_option)
{Called when a menu option has been selected}
Guard()
endEvent
event OnOptionMenuAccept(int a_option, int a_index)
{Called when a menu entry has been accepted}
Guard()
endEvent
event OnOptionColorOpen(int a_option)
{Called when a color option has been selected}
Guard()
endEvent
event OnOptionColorAccept(int a_option, int a_color)
{Called when a new color has been accepted}
Guard()
endEvent
event OnOptionKeyMapChange(int a_option, int a_keyCode, string a_conflictControl, string a_conflictName)
{Called when a key has been remapped}
Guard()
endEvent
; EVENTS ----------------------------------------------------------------------------- Version 2 --
event OnHighlightST()
{Called when highlighting a state option}
Guard()
endEvent
event OnSelectST()
{Called when a non-interactive state option has been selected}
Guard()
endEvent
event OnDefaultST()
{Called when resetting a state option to its default value}
Guard()
endEvent
event OnSliderOpenST()
{Called when a slider state option has been selected}
Guard()
endEvent
event OnSliderAcceptST(float a_value)
{Called when a new slider state value has been accepted}
Guard()
endEvent
event OnMenuOpenST()
{Called when a menu state option has been selected}
Guard()
endEvent
event OnMenuAcceptST(int a_index)
{Called when a menu entry has been accepted for this state option}
Guard()
endEvent
event OnColorOpenST()
{Called when a color state option has been selected}
Guard()
endEvent
event OnColorAcceptST(int a_color)
{Called when a new color has been accepted for this state option}
Guard()
endEvent
event OnKeyMapChangeST(int a_keyCode, string a_conflictControl, string a_conflictName)
{Called when a key has been remapped for this state option}
Guard()
endEvent
; FUNCTIONS -------------------------------------------------------------------------- Version 1 --
int function GetVersion()
{Returns version of this script. Override if necessary}
Guard()
endFunction
string function GetCustomControl(int a_keyCode)
{Returns the name of a custom control mapped to given keyCode, or "" if the key is not in use by this config. Override if necessary}
Guard()
endFunction
function ForcePageReset()
{Forces a full reset of the current page}
Guard()
endFunction
function SetTitleText(string a_text)
{Sets the title text of the control panel}
Guard()
endFunction
function SetInfoText(string a_text)
{Sets the text for the info text field below the option panel}
Guard()
endFunction
function SetCursorPosition(int a_position)
{Sets the position of the cursor used for the option setters}
Guard()
endFunction
function SetCursorFillMode(int a_fillMode)
{Sets the fill direction of the cursor used for the option setters}
Guard()
endFunction
int function AddEmptyOption()
{Adds an empty option, which can be used for padding instead of manually re-positioning the cursor}
Guard()
endFunction
int function AddHeaderOption(string a_text, int a_flags = 0)
{Adds a header option to group several options together}
Guard()
endFunction
int function AddTextOption(string a_text, string a_value, int a_flags = 0)
{Adds a generic text/value option}
Guard()
endFunction
int function AddToggleOption(string a_text, bool a_checked, int a_flags = 0)
{Adds a check box option that can be toggled on and off}
Guard()
endfunction
int function AddSliderOption(string a_text, float a_value, string a_formatString = "{0}", int a_flags = 0)
{Adds an option that opens a slider dialog when selected}
Guard()
endFunction
int function AddMenuOption(string a_text, string a_value, int a_flags = 0)
{Adds an option that opens a menu dialog when selected}
Guard()
endFunction
int function AddColorOption(string a_text, int a_color, int a_flags = 0)
{Adds an option that opens a color swatch dialog when selected}
Guard()
endFunction
int function AddKeyMapOption(string a_text, int a_keyCode, int a_flags = 0)
{Adds a key mapping option}
Guard()
endFunction
function LoadCustomContent(string a_source, float a_x = 0.0, float a_y = 0.0)
{Loads an external file into the option panel}
Guard()
endFunction
function UnloadCustomContent()
{Clears any custom content and re-enables the original option list}
Guard()
endFunction
function SetOptionFlags(int a_option, int a_flags, bool a_noUpdate = false)
{Sets the option flags}
Guard()
endFunction
function SetTextOptionValue(int a_option, string a_value, bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endFunction
function SetToggleOptionValue(int a_option, bool a_checked, bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endfunction
function SetSliderOptionValue(int a_option, float a_value, string a_formatString = "{0}", bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endFunction
function SetMenuOptionValue(int a_option, string a_value, bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endFunction
function SetColorOptionValue(int a_option, int a_color, bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endFunction
function SetKeyMapOptionValue(int a_option, int a_keyCode, bool a_noUpdate = false)
{Sets the value(s) of an existing option}
Guard()
endFunction
function SetSliderDialogStartValue(float a_value)
{Sets slider dialog parameter(s)}
Guard()
endFunction
function SetSliderDialogDefaultValue(float a_value)
{Sets slider dialog parameter(s)}
Guard()
endFunction
function SetSliderDialogRange(float a_minValue, float a_maxValue)
{Sets slider dialog parameter(s)}
Guard()
endFunction
function SetSliderDialogInterval(float a_value)
{Sets slider dialog parameter(s)}
Guard()
endFunction
function SetMenuDialogStartIndex(int a_value)
{Sets menu dialog parameter(s)}
Guard()
endFunction
function SetMenuDialogDefaultIndex(int a_value)
{Sets menu dialog parameter(s)}
Guard()
endFunction
function SetMenuDialogOptions(string[] a_options)
{Sets menu dialog parameter(s)}
Guard()
endFunction
function SetColorDialogStartColor(int a_color)
{Sets menu color parameter(s)}
Guard()
endFunction
function SetColorDialogDefaultColor(int a_color)
{Sets menu color parameter(s)}
Guard()
endFunction
bool function ShowMessage(string a_message, bool a_withCancel = true, string a_acceptLabel = "$Accept", string a_cancelLabel = "$Cancel")
{Shows a message dialog and waits until the user has closed it}
Guard()
endFunction
; FUNCTIONS -------------------------------------------------------------------------- Version 2 --
function AddTextOptionST(string a_stateName, string a_text, string a_value, int a_flags = 0)
{Adds a generic text/value state option}
Guard()
endFunction
function AddToggleOptionST(string a_stateName, string a_text, bool a_checked, int a_flags = 0)
{Adds a check box state option that can be toggled on and off}
Guard()
endfunction
function AddSliderOptionST(string a_stateName, string a_text, float a_value, string a_formatString = "{0}", int a_flags = 0)
{Adds a state option that opens a slider dialog when selected}
Guard()
endFunction
function AddMenuOptionST(string a_stateName, string a_text, string a_value, int a_flags = 0)
{Adds a state option that opens a menu dialog when selected}
Guard()
endFunction
function AddColorOptionST(string a_stateName, string a_text, int a_color, int a_flags = 0)
{Adds a state option that opens a color swatch dialog when selected}
Guard()
endFunction
function AddKeyMapOptionST(string a_stateName, string a_text, int a_keyCode, int a_flags = 0)
{Adds a key mapping state option}
Guard()
endFunction
function SetOptionFlagsST(int a_flags, bool a_noUpdate = false, string a_stateName = "")
{Sets the state option flags}
Guard()
endFunction
function SetTextOptionValueST(string a_value, bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
function SetToggleOptionValueST(bool a_checked, bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
function SetSliderOptionValueST(float a_value, string a_formatString = "{0}", bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
function SetMenuOptionValueST(string a_value, bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
function SetColorOptionValueST(int a_color, bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
function SetKeyMapOptionValueST(int a_keyCode, bool a_noUpdate = false, string a_stateName = "")
{Sets the value(s) of an existing state option}
Guard()
endFunction
; -------------------------------------------------------------------------------------------------
function Guard()
Debug.MessageBox("SKI_ConfigBase: Don't recompile this script!")
endFunction
| Papyrus | 5 | pragasette/skyui | dist/Data/Scripts/Headers/SKI_ConfigBase.psc | [
"Unlicense",
"MIT"
] |
implement main0 () =
println!("Hello, World!")
| ATS | 4 | vmchale/project-init | src/includes/ats/project.dats | [
"BSD-3-Clause"
] |
$$ MODE TUSCRIPT
numbers=RANDOM_NUMBERS (1,9,9),nr=0
SECTION check
LOOP o,n=numbers
IF (n!=o) THEN
DO PRINT
EXIT
ELSEIF (n==9&&o==9) THEN
DO PRINT
PRINT " You made it ... in round ",r
STOP
ELSE
CYCLE
ENDIF
ENDLOOP
ENDSECTION
SECTION print
PRINT numbers
ENDSECTION
DO PRINT
LOOP r=1,14
IF (nr>=0&&nr<10) THEN
ASK "Reverse - how many?": nr=""
i=""
LOOP n=1,nr
i=APPEND(i,n)
ENDLOOP
numbers =SPLIT (numbers)
reverse_nr=SELECT (numbers,#i,keep_nr), reverse_nr=REVERSE(reverse_nr)
numbers =APPEND (reverse_nr,keep_nr), numbers =JOIN (numbers)
DO check
ENDIF
ENDLOOP
| Turing | 3 | LaudateCorpus1/RosettaCodeData | Task/Number-reversal-game/TUSCRIPT/number-reversal-game.tu | [
"Info-ZIP"
] |
.template-item-details {
display: flex;
justify-content: space-between;
flex-wrap: wrap;
}
.template-item-details .template-item-details-sub {
width: 100%;
}
| CSS | 3 | dzma352/portainer | app/portainer/components/template-list/template-item/template-item.css | [
"Zlib"
] |
"""The tests for the utilities."""
| Python | 0 | MrDelik/core | tests/util/__init__.py | [
"Apache-2.0"
] |
polyhedron(
points=[
[10,10,0],
[10,-10,0],
[-10,-10,0],
[-10,10,0],
[0,0,10]
],
triangles=[
[0,1,4],
[1,2,4],
[2,3,4],
[3,0,4],
[1,0,3],
[2,1,3]
]
);
| OpenSCAD | 3 | heristhesiya/OpenJSCAD.org | packages/io/scad-deserializer/tests/examples/example011.scad | [
"MIT"
] |
body {
padding: 10px;
font-family: sans-serif;
}
| CSS | 1 | kennethsequeira/Hello-world | MeteorJS/client/main.css | [
"MIT"
] |
# Entry point of the nitfind command.
module cmd
import opts
import matcher
import reporter
import finder
var opt_ctx = new OptionContext
opt_ctx.options_before_rest = true
var usage = new OptionText("""Usage: nitfind [OPTIONS] PATTERN [FILES OR DIRECTORIES]
Search for PATTERN in each source file in the tree rooted at the current
directory. If any FILES or DIRECTORIES are specified, then only those are
searched. Multiple PATTERNs to search can be specified using the --match
flag.
""")
var ctx_lines = new OptionInt("Print NUM lines of output context", 0, "-C", "--context")
var ctx_before = new OptionInt("Print NUM lines of leading context before matching lines", 0, "-B", "--before-context")
var ctx_after = new OptionInt("Print NUM lines of trailing context after matching lines", 0, "-A", "--after-context")
var patterns = new OptionArray("Pattern to match, may be set more than once", "--match")
var help = new OptionBool("Display usage text", "-h", "--help")
opt_ctx.add_option(usage, ctx_after, ctx_before, ctx_lines, help, patterns)
opt_ctx.parse(args)
var rest = opt_ctx.rest
if rest.length == 0 and patterns.value.length == 0 then
print("A pattern to match must be specified")
opt_ctx.usage
exit(-1)
end
# If patterns is empty, then the pattern is the first rest parameter.
var search_patterns = patterns.value
if search_patterns.is_empty then search_patterns = [rest.shift]
# If no directory/files are specified, search in the current directory.
var dir = "."
if rest.length > 0 then dir = rest[0] # TODO : support multiple directories/files
# By default, ignore dotfiles and dot directories
# TODO : support flag to alter this behaviour
var dot_matcher = new ReMatcher("^\\.".to_re)
var nodot_matcher = new NotMatcher(dot_matcher)
var resolver = new DirFileResolver(dir, nodot_matcher)
resolver.dir_matcher = nodot_matcher
var reporter = new AckReporter.with_ctx_lines(ctx_before.value, ctx_after.value)
# Buid the matchers
var matchers = new Array[Matcher]
for pat in search_patterns do
matchers.add(new LitMatcher(pat, false)) # TODO : support flags for regex, case insensitive
end
var all_matcher = new AllMatcher
all_matcher.add_matchers(matchers...)
var finder = new Finder(all_matcher, resolver, reporter)
if finder.find == 0 then exit(1)
| Nit | 5 | PuerkitoBio/nitfind | cmd.nit | [
"BSD-3-Clause"
] |
#!/usr/bin/env bash
SCRCPY_SERVER_PATH="$MESON_BUILD_ROOT/server/scrcpy-server" "$MESON_BUILD_ROOT/app/scrcpy"
| Shell | 2 | LuckyNigel/scrcpy | scripts/run-scrcpy.sh | [
"Apache-2.0"
] |
module audiostreamerscrobbler.groups.BaseGroupStragegyImpl
import audiostreamerscrobbler.groups.GroupProcessEventTypes.types.GroupProcessEvents
union PlayerStatus = {
Idle
Playing
}
let DEBUG = false
let KEY_STATE = "state"
let KEY_PLAYER = "player"
function createBaseGroupStragegyImpl = |playerTypes, cbProcessEvents| {
# Some notes:
# 1) This is one of the few objects in this program that is specifically meant to
# be overwritten by the object that creates this object instance (for example
# to directly provide implementations for the unimplemented methods).
# 2) No implementations are provided for the handleDetectedEvent() and handleLostEvent()
# event handlers and the afterIdleEvent() function.
# 3) Users of this implementation that do not re-implement the handleIdleEvent()
# function are required to provide the implementation for the afterIdleEvent
# function, which is called in this class' handleIdleEvent() implementation.
# 4) Strategies based on this implementation are definitely not threadsafe
let players = map[]
let activePlayerTypes = set[]
let strategyImpl = DynamicObject("BaseGroupStragegyImpl"):
define("playerTypes", playerTypes):
define("activePlayerTypes", activePlayerTypes):
define("cbProcessEvents", |this| -> cbProcessEvents):
define("addPlayer", |this, player| -> addPlayer(this, player)):
define("removePlayer", |this, player| -> removePlayer(this, player)):
define("hasPlayer", |this, player| -> hasPlayer(this, player)):
define("players", players):
define("activePlayers", |this| -> activePlayers(this)):
define("playerInGroupPlaying", |this| -> playerInGroupPlaying(this)):
define("startAllDetectors", |this| -> this: startDetectors(|t| -> true)):
define("startDetectors", |this, f| -> startDetectors(this, f)):
define("stopAllDetectors", |this| -> this: stopDetectors(|t| -> true)):
define("stopDetectors", |this, f| -> stopDetectors(this, f)):
define("startMonitors", |this, f| -> startMonitors(this, f)):
define("stopMonitors", |this, f| -> stopMonitors(this, f)):
define("handleInitializationEvent", |this, group, event| -> handleInitializationEvent(this, group, event)):
define("handleDetectedEvent", |this, group, event| -> notImplemented("handleDetectedEvent")):
define("handleLostEvent", |this, group, event| -> notImplemented("handleLostEvent")):
define("handlePlayingEvent", |this, group, event| -> handlePlayingEvent(this, group, event)):
define("afterPlayingEvent", |this, group, event| -> afterPlayingEvent(this, group, event)):
define("handleIdleEvent", |this, group, event| -> handleIdleEvent(this, group, event)):
define("afterIdleEvent", |this, group, event| -> notImplemented("afterIdleEvent")):
define("event", |this, group, e| -> onEvent(this, group, e))
return strategyImpl
}
local function notImplemented = |m| {
throw IllegalStateException(m + "() was not implemented?!")
}
local function addPlayer = |impl, player| {
impl: players(): put(player: id(), map[
[KEY_STATE, PlayerStatus.Idle()],
[KEY_PLAYER, player]])
}
local function removePlayer = |impl, player| {
return impl: players(): remove(player: id())
}
local function hasPlayer = |impl, player| {
return impl: players(): containsKey(player: id())
}
local function activePlayers = |impl| {
return set[m: get(KEY_PLAYER) foreach m in impl: players(): values()]
}
local function playerInGroupPlaying = |impl| {
foreach e in impl: players(): entrySet() {
if (e: getValue(): get(KEY_STATE): isPlaying()) {
return e: getValue(): get(KEY_PLAYER)
}
}
return null
}
local function startDetectors = |impl, f| {
let playerTypes = list[t foreach t in impl: playerTypes() when f(t)]
_startOrStopDetectors(impl, playerTypes, |t| -> GroupProcessEvents.StartDetectors(t))
impl: activePlayerTypes(): addAll(playerTypes)
}
local function stopDetectors = |impl, f| {
let playerTypes = list[t foreach t in impl: activePlayerTypes() when f(t)]
_startOrStopDetectors(impl, playerTypes, |t| -> GroupProcessEvents.StopDetectors(t))
impl: activePlayerTypes(): removeAll(playerTypes)
}
local function _startOrStopDetectors = |impl, playerTypes, groupProcessEvent| {
if (not playerTypes: isEmpty()) {
let cbProcessEvents = impl: cbProcessEvents()
cbProcessEvents(groupProcessEvent([t foreach t in playerTypes]))
}
}
local function startMonitors = |impl, f| {
_startOrStopMonitors(impl, f, |p| -> GroupProcessEvents.StartMonitors(p))
}
local function stopMonitors = |impl, f| {
_startOrStopMonitors(impl, f, |p| -> GroupProcessEvents.StopMonitors(p))
}
local function _startOrStopMonitors = |impl, f, groupProcessEvent| {
let cbProcessEvents = impl: cbProcessEvents()
let players = [p foreach p in activePlayers(impl) when f(p)]
if (not players: isEmpty()) {
cbProcessEvents(groupProcessEvent(players))
}
}
local function handleInitializationEvent = |impl, group, event| {
impl: startAllDetectors()
}
local function handlePlayingEvent = |impl, group, event| {
let player = event: player()
if not hasPlayer(impl, player) {
if (DEBUG) {
println("Group '" + group: name() + "' does not manage the '" + player: friendlyName() + "' player at this time")
}
return false
}
let playingPlayer = playerInGroupPlaying(impl)
if (playingPlayer isnt null) {
if (DEBUG and player: id() != playingPlayer: id()) {
println("A different player in this group is already playing")
}
return false
}
impl: players(): get(player: id()): put(KEY_STATE , PlayerStatus.Playing())
impl: afterPlayingEvent(group, event)
return true
}
local function afterPlayingEvent = |impl, group, event| {
impl: stopAllDetectors()
let player = event: player()
stopMonitors(impl, |p| -> p: id() != player: id())
# Remove idle players from player list. They will be detected once more, once
# the currently playing player becomes idle
_removeIdlePlayers(impl)
}
local function _removeIdlePlayers = |impl| {
let idlePlayerIds = list[]
foreach e in impl: players(): entrySet() {
if (e: getValue(): get(KEY_STATE): isIdle()) {
idlePlayerIds: add(e: getKey())
}
}
idlePlayerIds: each(|id| {
impl: players(): remove(id)
})
}
local function handleIdleEvent = |impl, group, event| {
let player = event: player()
if not hasPlayer(impl, player) {
if (DEBUG) {
println("Group '" + group: name() + "' is currently not managing the '" + player: friendlyName() + "' player. No need to handle idle event.")
}
return false
} else if (not impl: players(): get(player: id()): get(KEY_STATE): isPlaying()) {
if (DEBUG) {
println("Player '" + player: friendlyName() + "' is not playing. No need to handle idle event")
}
return false
}
println("Player '" + player: friendlyName() + "' is not playing anymore")
impl: players(): get(player: id()): put(KEY_STATE , PlayerStatus.Idle())
impl: afterIdleEvent(group, event)
return true
}
local function onEvent = |impl, group, event| {
case {
when event: isInitializationEvent() {
impl: handleInitializationEvent(group, event)
}
when event: isDetectedEvent() {
impl: handleDetectedEvent(group, event)
}
when event: isLostEvent() {
impl: handleLostEvent(group, event)
}
when event: isPlayingEvent() {
impl: handlePlayingEvent(group, event)
}
when event: isIdleEvent() {
impl: handleIdleEvent(group, event)
}
otherwise {
raise("Internal error: unknown group event '" + event + "'")
}
}
}
# Support functions
local function _getActivePlayerTypes = |impl| {
return set[p: playerType() foreach p in activePlayers(impl)]
} | Golo | 4 | vvdleun/audiostreamerscrobbler | src/main/golo/include/groups/BaseGroupStragegyImpl.golo | [
"MIT"
] |
values = []
for i in range(10):
break if i > 4
values.Add(i)
assert values == [0, 1, 2, 3, 4]
| Boo | 1 | popcatalin81/boo | tests/testcases/integration/statements/for-5.boo | [
"BSD-3-Clause"
] |
= Documentation for Close Account Feature
The close account feature allows users to close their accounts.
== Auth Value Methods
account_closed_status_value :: The integer representing closed accounts.
close_account_additional_form_tags :: HTML fragment containing additional form tags to use on the close account form.
close_account_button :: The text to use for the close account button.
close_account_error_flash :: The flash error to show if there is an error closing the account.
close_account_notice_flash :: The flash notice to show after closing the account.
close_account_page_title :: The page title to use on the close account form.
close_account_redirect :: Where to redirect after closing the account.
close_account_requires_password? :: Whether a password is required when closing accounts.
close_account_route :: The route to the close account action. Defaults to +close-account+.
delete_account_on_close? :: Whether to delete the account when closing it, default value is to use +skip_status_checks?+.
== Auth Methods
after_close_account :: Run arbitrary code after closing the account.
before_close_account :: Run arbitrary code before closing an account.
before_close_account_route :: Run arbitrary code before handling a close account route.
close_account :: Close the account, by default setting the account status to closed.
close_account_view :: The HTML to use for the close account form.
delete_account :: If +delete_account_on_close?+ is true, delete the account when closing it.
| RDoc | 4 | monorkin/rodauth | doc/close_account.rdoc | [
"MIT"
] |
/*--------------------------------------------------*/
/* SAS Programming for R Users - code for exercises */
/* Copyright 2016 SAS Institute Inc. */
/*--------------------------------------------------*/
/*SP4R03s05*/
/*Part A*/
data sp4r.sports(keep= make type msrp);
set sp4r.cars;
where type='Sports' and msrp>100000;
run;
/*Part B*/
data sp4r.suv(keep= make type msrp);
set sp4r.cars;
where type='SUV' and msrp>60000;
run;
/*Part C*/
data sp4r.expensive;
set sp4r.sports sp4r.suv;
run;
proc print data= sp4r.expensive;
run;
| SAS | 4 | snowdj/sas-prog-for-r-users | code/SP4R03s05.sas | [
"CC-BY-4.0"
] |
module NotFound.Model exposing (Model)
import Login.Login as Login
import Routes
type alias Model =
Login.Model
{ route : Routes.Route
, notFoundImgSrc : String
}
| Elm | 3 | Caprowni/concourse | web/elm/src/NotFound/Model.elm | [
"Apache-2.0"
] |
"""Support for restoring entity states on startup."""
from __future__ import annotations
from abc import abstractmethod
import asyncio
from datetime import datetime, timedelta
import logging
from typing import Any, TypeVar, cast
from homeassistant.const import ATTR_RESTORED, EVENT_HOMEASSISTANT_STOP
from homeassistant.core import HomeAssistant, State, callback, valid_entity_id
from homeassistant.exceptions import HomeAssistantError
import homeassistant.util.dt as dt_util
from . import start
from .entity import Entity
from .event import async_track_time_interval
from .json import JSONEncoder
from .singleton import singleton
from .storage import Store
DATA_RESTORE_STATE_TASK = "restore_state_task"
_LOGGER = logging.getLogger(__name__)
STORAGE_KEY = "core.restore_state"
STORAGE_VERSION = 1
# How long between periodically saving the current states to disk
STATE_DUMP_INTERVAL = timedelta(minutes=15)
# How long should a saved state be preserved if the entity no longer exists
STATE_EXPIRATION = timedelta(days=7)
_StoredStateT = TypeVar("_StoredStateT", bound="StoredState")
class ExtraStoredData:
"""Object to hold extra stored data."""
@abstractmethod
def as_dict(self) -> dict[str, Any]:
"""Return a dict representation of the extra data.
Must be serializable by Home Assistant's JSONEncoder.
"""
class RestoredExtraData(ExtraStoredData):
"""Object to hold extra stored data loaded from storage."""
def __init__(self, json_dict: dict[str, Any]) -> None:
"""Object to hold extra stored data."""
self.json_dict = json_dict
def as_dict(self) -> dict[str, Any]:
"""Return a dict representation of the extra data."""
return self.json_dict
class StoredState:
"""Object to represent a stored state."""
def __init__(
self,
state: State,
extra_data: ExtraStoredData | None,
last_seen: datetime,
) -> None:
"""Initialize a new stored state."""
self.extra_data = extra_data
self.last_seen = last_seen
self.state = state
def as_dict(self) -> dict[str, Any]:
"""Return a dict representation of the stored state."""
result = {
"state": self.state.as_dict(),
"extra_data": self.extra_data.as_dict() if self.extra_data else None,
"last_seen": self.last_seen,
}
return result
@classmethod
def from_dict(cls: type[_StoredStateT], json_dict: dict) -> _StoredStateT:
"""Initialize a stored state from a dict."""
extra_data_dict = json_dict.get("extra_data")
extra_data = RestoredExtraData(extra_data_dict) if extra_data_dict else None
last_seen = json_dict["last_seen"]
if isinstance(last_seen, str):
last_seen = dt_util.parse_datetime(last_seen)
return cls(
cast(State, State.from_dict(json_dict["state"])), extra_data, last_seen
)
class RestoreStateData:
"""Helper class for managing the helper saved data."""
@staticmethod
@singleton(DATA_RESTORE_STATE_TASK)
async def async_get_instance(hass: HomeAssistant) -> RestoreStateData:
"""Get the singleton instance of this data helper."""
data = RestoreStateData(hass)
try:
stored_states = await data.store.async_load()
except HomeAssistantError as exc:
_LOGGER.error("Error loading last states", exc_info=exc)
stored_states = None
if stored_states is None:
_LOGGER.debug("Not creating cache - no saved states found")
data.last_states = {}
else:
data.last_states = {
item["state"]["entity_id"]: StoredState.from_dict(item)
for item in stored_states
if valid_entity_id(item["state"]["entity_id"])
}
_LOGGER.debug("Created cache with %s", list(data.last_states))
async def hass_start(hass: HomeAssistant) -> None:
"""Start the restore state task."""
data.async_setup_dump()
start.async_at_start(hass, hass_start)
return data
@classmethod
async def async_save_persistent_states(cls, hass: HomeAssistant) -> None:
"""Dump states now."""
data = await cls.async_get_instance(hass)
await data.async_dump_states()
def __init__(self, hass: HomeAssistant) -> None:
"""Initialize the restore state data class."""
self.hass: HomeAssistant = hass
self.store: Store = Store(
hass, STORAGE_VERSION, STORAGE_KEY, encoder=JSONEncoder
)
self.last_states: dict[str, StoredState] = {}
self.entities: dict[str, RestoreEntity] = {}
@callback
def async_get_stored_states(self) -> list[StoredState]:
"""Get the set of states which should be stored.
This includes the states of all registered entities, as well as the
stored states from the previous run, which have not been created as
entities on this run, and have not expired.
"""
now = dt_util.utcnow()
all_states = self.hass.states.async_all()
# Entities currently backed by an entity object
current_entity_ids = {
state.entity_id
for state in all_states
if not state.attributes.get(ATTR_RESTORED)
}
# Start with the currently registered states
stored_states = [
StoredState(
state, self.entities[state.entity_id].extra_restore_state_data, now
)
for state in all_states
if state.entity_id in self.entities and
# Ignore all states that are entity registry placeholders
not state.attributes.get(ATTR_RESTORED)
]
expiration_time = now - STATE_EXPIRATION
for entity_id, stored_state in self.last_states.items():
# Don't save old states that have entities in the current run
# They are either registered and already part of stored_states,
# or no longer care about restoring.
if entity_id in current_entity_ids:
continue
# Don't save old states that have expired
if stored_state.last_seen < expiration_time:
continue
stored_states.append(stored_state)
return stored_states
async def async_dump_states(self) -> None:
"""Save the current state machine to storage."""
_LOGGER.debug("Dumping states")
try:
await self.store.async_save(
[
stored_state.as_dict()
for stored_state in self.async_get_stored_states()
]
)
except HomeAssistantError as exc:
_LOGGER.error("Error saving current states", exc_info=exc)
@callback
def async_setup_dump(self, *args: Any) -> None:
"""Set up the restore state listeners."""
async def _async_dump_states(*_: Any) -> None:
await self.async_dump_states()
# Dump the initial states now. This helps minimize the risk of having
# old states loaded by overwriting the last states once Home Assistant
# has started and the old states have been read.
self.hass.async_create_task(_async_dump_states())
# Dump states periodically
cancel_interval = async_track_time_interval(
self.hass, _async_dump_states, STATE_DUMP_INTERVAL
)
async def _async_dump_states_at_stop(*_: Any) -> None:
cancel_interval()
await self.async_dump_states()
# Dump states when stopping hass
self.hass.bus.async_listen_once(
EVENT_HOMEASSISTANT_STOP, _async_dump_states_at_stop
)
@callback
def async_restore_entity_added(self, entity: RestoreEntity) -> None:
"""Store this entity's state when hass is shutdown."""
self.entities[entity.entity_id] = entity
@callback
def async_restore_entity_removed(
self, entity_id: str, extra_data: ExtraStoredData | None
) -> None:
"""Unregister this entity from saving state."""
# When an entity is being removed from hass, store its last state. This
# allows us to support state restoration if the entity is removed, then
# re-added while hass is still running.
state = self.hass.states.get(entity_id)
# To fully mimic all the attribute data types when loaded from storage,
# we're going to serialize it to JSON and then re-load it.
if state is not None:
state = State.from_dict(_encode_complex(state.as_dict()))
if state is not None:
self.last_states[entity_id] = StoredState(
state, extra_data, dt_util.utcnow()
)
self.entities.pop(entity_id)
def _encode(value: Any) -> Any:
"""Little helper to JSON encode a value."""
try:
return JSONEncoder.default(
None, # type: ignore[arg-type]
value,
)
except TypeError:
return value
def _encode_complex(value: Any) -> Any:
"""Recursively encode all values with the JSONEncoder."""
if isinstance(value, dict):
return {_encode(key): _encode_complex(value) for key, value in value.items()}
if isinstance(value, list):
return [_encode_complex(val) for val in value]
new_value = _encode(value)
if isinstance(new_value, type(value)):
return new_value
return _encode_complex(new_value)
class RestoreEntity(Entity):
"""Mixin class for restoring previous entity state."""
async def async_internal_added_to_hass(self) -> None:
"""Register this entity as a restorable entity."""
_, data = await asyncio.gather(
super().async_internal_added_to_hass(),
RestoreStateData.async_get_instance(self.hass),
)
data.async_restore_entity_added(self)
async def async_internal_will_remove_from_hass(self) -> None:
"""Run when entity will be removed from hass."""
_, data = await asyncio.gather(
super().async_internal_will_remove_from_hass(),
RestoreStateData.async_get_instance(self.hass),
)
data.async_restore_entity_removed(self.entity_id, self.extra_restore_state_data)
async def _async_get_restored_data(self) -> StoredState | None:
"""Get data stored for an entity, if any."""
if self.hass is None or self.entity_id is None:
# Return None if this entity isn't added to hass yet
_LOGGER.warning("Cannot get last state. Entity not added to hass") # type: ignore[unreachable]
return None
data = cast(
RestoreStateData, await RestoreStateData.async_get_instance(self.hass)
)
if self.entity_id not in data.last_states:
return None
return data.last_states[self.entity_id]
async def async_get_last_state(self) -> State | None:
"""Get the entity state from the previous run."""
if (stored_state := await self._async_get_restored_data()) is None:
return None
return stored_state.state
async def async_get_last_extra_data(self) -> ExtraStoredData | None:
"""Get the entity specific state data from the previous run."""
if (stored_state := await self._async_get_restored_data()) is None:
return None
return stored_state.extra_data
@property
def extra_restore_state_data(self) -> ExtraStoredData | None:
"""Return entity specific state data to be restored.
Implemented by platform classes.
"""
return None
| Python | 5 | MrDelik/core | homeassistant/helpers/restore_state.py | [
"Apache-2.0"
] |
At: "001.hac":3:
parse error: syntax error
parser stacks:
state value
#STATE# (null)
#STATE# (null)
#STATE# (null)
#STATE# keyword: defproc [3:1..7]
#STATE# identifier: empty [3:9..13]
#STATE# ( [3:14]
#STATE# (chan-type) [3:15..19]
#STATE# ( [3:20]
#STATE# list<(type-ref)>: ... [0:0]
#STATE# keyword: chan [3:21..24]
in state #STATE#, possible rules are:
data_type_ref_list_optional_in_parens: '(' data_type_ref_list_optional . ')' (#RULE#)
acceptable tokens are:
')' (shift)
| Bison | 0 | broken-wheel/hacktist | hackt_docker/hackt/test/parser/chp/001.stderr.bison | [
"MIT"
] |
BtensorJ
| PureBasic | 0 | pchandrasekaran1595/onnx | onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb | [
"Apache-2.0"
] |
insert into USERS(name, status, id) values('Peter', 1, 1);
insert into USERS(name, status, id) values('David', 1, 2);
insert into USERS(name, status, id) values('Ed', 1, 3);
| SQL | 1 | zeesh49/tutorials | spring-boot-persistence/src/test/resources/import_active_users.sql | [
"MIT"
] |
const __floattitf = @import("floattitf.zig").__floattitf;
const testing = @import("std").testing;
fn test__floattitf(a: i128, expected: f128) !void {
const x = __floattitf(a);
try testing.expect(x == expected);
}
test "floattitf" {
try test__floattitf(0, 0.0);
try test__floattitf(1, 1.0);
try test__floattitf(2, 2.0);
try test__floattitf(20, 20.0);
try test__floattitf(-1, -1.0);
try test__floattitf(-2, -2.0);
try test__floattitf(-20, -20.0);
try test__floattitf(0x7FFFFF8000000000, 0x1.FFFFFEp+62);
try test__floattitf(0x7FFFFFFFFFFFF800, 0x1.FFFFFFFFFFFFEp+62);
try test__floattitf(0x7FFFFF0000000000, 0x1.FFFFFCp+62);
try test__floattitf(0x7FFFFFFFFFFFF000, 0x1.FFFFFFFFFFFFCp+62);
try test__floattitf(make_ti(0x8000008000000000, 0), -0x1.FFFFFEp+126);
try test__floattitf(make_ti(0x8000000000000800, 0), -0x1.FFFFFFFFFFFFEp+126);
try test__floattitf(make_ti(0x8000010000000000, 0), -0x1.FFFFFCp+126);
try test__floattitf(make_ti(0x8000000000001000, 0), -0x1.FFFFFFFFFFFFCp+126);
try test__floattitf(make_ti(0x8000000000000000, 0), -0x1.000000p+127);
try test__floattitf(make_ti(0x8000000000000001, 0), -0x1.FFFFFFFFFFFFFFFCp+126);
try test__floattitf(0x0007FB72E8000000, 0x1.FEDCBAp+50);
try test__floattitf(0x0007FB72EA000000, 0x1.FEDCBA8p+50);
try test__floattitf(0x0007FB72EB000000, 0x1.FEDCBACp+50);
try test__floattitf(0x0007FB72EBFFFFFF, 0x1.FEDCBAFFFFFFCp+50);
try test__floattitf(0x0007FB72EC000000, 0x1.FEDCBBp+50);
try test__floattitf(0x0007FB72E8000001, 0x1.FEDCBA0000004p+50);
try test__floattitf(0x0007FB72E6000000, 0x1.FEDCB98p+50);
try test__floattitf(0x0007FB72E7000000, 0x1.FEDCB9Cp+50);
try test__floattitf(0x0007FB72E7FFFFFF, 0x1.FEDCB9FFFFFFCp+50);
try test__floattitf(0x0007FB72E4000001, 0x1.FEDCB90000004p+50);
try test__floattitf(0x0007FB72E4000000, 0x1.FEDCB9p+50);
try test__floattitf(0x023479FD0E092DC0, 0x1.1A3CFE870496Ep+57);
try test__floattitf(0x023479FD0E092DA1, 0x1.1A3CFE870496D08p+57);
try test__floattitf(0x023479FD0E092DB0, 0x1.1A3CFE870496D8p+57);
try test__floattitf(0x023479FD0E092DB8, 0x1.1A3CFE870496DCp+57);
try test__floattitf(0x023479FD0E092DB6, 0x1.1A3CFE870496DBp+57);
try test__floattitf(0x023479FD0E092DBF, 0x1.1A3CFE870496DF8p+57);
try test__floattitf(0x023479FD0E092DC1, 0x1.1A3CFE870496E08p+57);
try test__floattitf(0x023479FD0E092DC7, 0x1.1A3CFE870496E38p+57);
try test__floattitf(0x023479FD0E092DC8, 0x1.1A3CFE870496E4p+57);
try test__floattitf(0x023479FD0E092DCF, 0x1.1A3CFE870496E78p+57);
try test__floattitf(0x023479FD0E092DD0, 0x1.1A3CFE870496E8p+57);
try test__floattitf(0x023479FD0E092DD1, 0x1.1A3CFE870496E88p+57);
try test__floattitf(0x023479FD0E092DD8, 0x1.1A3CFE870496ECp+57);
try test__floattitf(0x023479FD0E092DDF, 0x1.1A3CFE870496EF8p+57);
try test__floattitf(0x023479FD0E092DE0, 0x1.1A3CFE870496Fp+57);
try test__floattitf(make_ti(0x023479FD0E092DC0, 0), 0x1.1A3CFE870496Ep+121);
try test__floattitf(make_ti(0x023479FD0E092DA1, 1), 0x1.1A3CFE870496D08p+121);
try test__floattitf(make_ti(0x023479FD0E092DB0, 2), 0x1.1A3CFE870496D8p+121);
try test__floattitf(make_ti(0x023479FD0E092DB8, 3), 0x1.1A3CFE870496DCp+121);
try test__floattitf(make_ti(0x023479FD0E092DB6, 4), 0x1.1A3CFE870496DBp+121);
try test__floattitf(make_ti(0x023479FD0E092DBF, 5), 0x1.1A3CFE870496DF8p+121);
try test__floattitf(make_ti(0x023479FD0E092DC1, 6), 0x1.1A3CFE870496E08p+121);
try test__floattitf(make_ti(0x023479FD0E092DC7, 7), 0x1.1A3CFE870496E38p+121);
try test__floattitf(make_ti(0x023479FD0E092DC8, 8), 0x1.1A3CFE870496E4p+121);
try test__floattitf(make_ti(0x023479FD0E092DCF, 9), 0x1.1A3CFE870496E78p+121);
try test__floattitf(make_ti(0x023479FD0E092DD0, 0), 0x1.1A3CFE870496E8p+121);
try test__floattitf(make_ti(0x023479FD0E092DD1, 11), 0x1.1A3CFE870496E88p+121);
try test__floattitf(make_ti(0x023479FD0E092DD8, 12), 0x1.1A3CFE870496ECp+121);
try test__floattitf(make_ti(0x023479FD0E092DDF, 13), 0x1.1A3CFE870496EF8p+121);
try test__floattitf(make_ti(0x023479FD0E092DE0, 14), 0x1.1A3CFE870496Fp+121);
try test__floattitf(make_ti(0, 0xFFFFFFFFFFFFFFFF), 0x1.FFFFFFFFFFFFFFFEp+63);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC2801), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3000), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC37FF), 0x1.23456789ABCDEF0123456789ABC3p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC3800), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4000), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC47FF), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4800), 0x1.23456789ABCDEF0123456789ABC4p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC4801), 0x1.23456789ABCDEF0123456789ABC5p+124);
try test__floattitf(make_ti(0x123456789ABCDEF0, 0x123456789ABC57FF), 0x1.23456789ABCDEF0123456789ABC5p+124);
}
fn make_ti(high: u64, low: u64) i128 {
var result: u128 = high;
result <<= 64;
result |= low;
return @bitCast(i128, result);
}
| Zig | 5 | lukekras/zig | lib/std/special/compiler_rt/floattitf_test.zig | [
"MIT"
] |
/**
* Syllogism (Greek: συλλογισμός syllogismos,
* "conclusion, inference") is a kind of logical argument
* that applies deductive reasoning to arrive at a
* conclusion based on two or more propositions that
* are asserted or assumed to be true.
*
* In its earliest form, defined by Aristotle, from the
* combination of a general statement (the major premise)
* and a specific statement (the minor premise), a conclusion
* is deduced.
*
* For example, knowing that all men are mortal (major premise)
* and that Socrates is a man (minor premise), we may validly
* conclude that Socrates is mortal. Syllogistic arguments
* are usually represented in a three-line form:
*
* All men are mortal.
* Socrates is a man.
* Therefore Socrates is mortal.
*/
sig Men{}
one sig Socrates {}
check {
all mortal, men : some Men + Socrates {
men in mortal
and
Socrates in men
=> Socrates in mortal
}
} for 5 Men
/**
* This is very error prone since the following is not correct:
*
* All men are mortal.
* Socrates is a mortal.
* Therefore Socrates is a man.
*
* Running the following example will therefore fail
*/
check {
all mortal, men : some Men + Socrates {
men in mortal
and
Socrates in mortal
=> Socrates in men
}
} for 5 Men
| Alloy | 5 | c-luu/alloy-specs | logic/syllogism/syllogism.als | [
"Apache-2.0"
] |
/* Guides.rubyonrails.org */
/* Style.css */
/* Created January 30, 2009
--------------------------------------- */
/*
---------------------------------------
Import advanced style sheet
---------------------------------------
*/
@import url("reset.css");
@import url("main.css");
@import url("dark.css");
@import url("turbolinks.css");
| CSS | 3 | jstncarvalho/rails | guides/assets/stylesheets/style.css | [
"MIT"
] |
<!DOCTYPE html>
<html>
<head>
<title>Phalcon PHP Framework</title>
</head>
<body>
{{ content() }}
</body>
</html> | Volt | 2 | derryberni/mvc | simple-volt/app/views/index.volt | [
"BSD-3-Clause"
] |
60 mtof 0.1 bltriangle
| SourcePawn | 1 | aleatoricforest/Sporth | examples/bltriangle.sp | [
"MIT"
] |
{{#each document}}
<tr class="jta_tr">
<td class="col-record-td" data-col="record"><div class="jta_value col-record">{{record}}</div></td>
{{#each cells}}
{{print_safe this}}
{{/each}}
</tr>
{{/each}}
| Handlebars | 3 | zadcha/rethinkdb | admin/static/handlebars/dataexplorer_result_json_table_tr_value.hbs | [
"Apache-2.0"
] |
% original code:
% https://github.com/openlilylib/oll-core/blob/master/internal/predicates.scm
#(begin
(define (lilypond-version-string)
(string-join
(map (lambda (elt) (if (integer? elt) (number->string elt) elt))
(ly:version))
"."))
(display (format "~a\n~a\n" (lilypond-version-string) (ly:get-option 'datadir)))
)
| LilyPond | 4 | HolgerPeters/lyp | lib/lyp/etc/detect_system_lilypond.ly | [
"MIT"
] |
<p>Included file #2 ({$localvar}, {$hello})</p>
Parent: {basename($this->getReferringTemplate()->getName())}/{$this->getReferenceType()}
| Latte | 1 | TheDigitalOrchard/latte | tests/Latte/templates/subdir/include2.latte | [
"BSD-3-Clause"
] |
sealed class Base {
class A : Base()
class B : Base()
class C : Base()
} | Groff | 2 | qussarah/declare | jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded/Base.kt.new.1 | [
"Apache-2.0"
] |
{ lib, fetchzip }:
let
version = "20130214";
in fetchzip {
name = "caladea-${version}";
url = "https://commondatastorage.googleapis.com/chromeos-localmirror/distfiles/crosextrafonts-${version}.tar.gz";
postFetch = ''
tar -xzvf $downloadedFile --strip-components=1
mkdir -p $out/etc/fonts/conf.d
mkdir -p $out/share/fonts/truetype
cp -v *.ttf $out/share/fonts/truetype
cp -v ${./cambria-alias.conf} $out/etc/fonts/conf.d/30-cambria.conf
'';
sha256 = "0kwm42ggr8kvcn3554cpmv90xzam1sdncx7x3zs3bzp88mxrnv1z";
meta = with lib; {
# This font doesn't appear to have any official web site but this
# one provides some good information and samples.
homepage = "http://openfontlibrary.org/en/font/caladea";
description = "A serif font metric-compatible with Microsoft Cambria";
longDescription = ''
Caladea is a free font that is metric-compatible with the
Microsoft Cambria font. Developed by Carolina Giovagnoli and
Andrés Torresi at Huerta Tipográfica foundry.
'';
license = licenses.asl20;
platforms = platforms.all;
maintainers = [maintainers.rycee];
# Reduce the priority of this package. The intent is that if you
# also install the `vista-fonts` package, then you probably will
# not want to install the font alias of this package.
priority = 10;
};
}
| Nix | 4 | collinwright/nixpkgs | pkgs/data/fonts/caladea/default.nix | [
"MIT"
] |
\documentclass{article}
\usepackage{bbm}
\usepackage[greek,english]{babel}
\usepackage{ucs}
\usepackage[utf8x]{inputenc}
\usepackage{autofe}
\usepackage{agda}
\begin{document}
\begin{code}
data αβγδεζθικλμνξρστυφχψω : Set₁ where
postulate
→⇒⇛⇉⇄↦⇨↠⇀⇁ : Set
\end{code}
\[
∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ]
\]
\end{document}
| Literate Agda | 3 | andorp/plfa.github.io | papers/sbmf/text.lagda | [
"CC-BY-4.0"
] |
10 5 2 0
0 1 7 4 2 9 10 7 6 1 [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]
1 3 3 11 3 5 [10 6 7] [5 27 22 13 9 3 14 13 13] [2 25 28 14 -3 -1 -1 -5 6]
2 3 3 5 11 8 [1 0 0 4 12 0 1 0 1] [1 8 1] [2 0 3 8 12 0 0 0 3]
3 3 2 11 7 [4 7 5] [0 0 -1 -6 -1 1 -4 0 11]
4 3 2 10 11 [10 0 10 6 0 4 23 15 13] [4 2 8]
5 3 3 7 4 1 [3 3 2 0 1 0 4 -1 5] [0 2 2 3 2 0 -2 1 0] [-4 -21 -8 -4 -7 -10 -24 -9 -12]
6 3 2 9 11 [7 12 4 12 17 -5 19 24 16] [8 6 8]
7 3 1 10 [0 0 1 14 12 7 0 3 1]
8 3 3 6 11 4 [12 29 0 3 5 6 16 15 -4] [10 2 6] [10 16 -6 4 -1 3 -2 5 5]
9 3 2 3 11 [15 8 15 11 10 15 -2 0 8] [5 5 5]
10 3 2 11 4 [10 5 7] [-9 -6 -19 -14 -10 -15 -11 -21 -7]
11 1 0
0 1 0 0 0 0 0 0 0 0
1 1 10 4 3 2 2 3 1 5
2 6 4 3 2 2 3 1 5
3 7 4 3 2 2 3 1 5
2 1 1 5 3 1 3 4 3 5
2 8 5 3 1 3 4 3 5
3 1 5 3 1 3 4 3 5
3 1 4 2 1 3 3 5 2 4
2 7 2 1 3 3 5 2 4
3 5 2 1 3 3 5 2 4
4 1 4 3 1 3 2 2 2 4
2 2 3 1 3 2 2 2 4
3 8 3 1 3 2 2 2 4
5 1 1 2 5 5 1 4 4 5
2 1 2 5 5 1 4 4 5
3 3 2 5 5 1 4 4 5
6 1 8 2 1 5 2 2 5 1
2 6 2 1 5 2 2 5 1
3 8 2 1 5 2 2 5 1
7 1 2 1 4 1 2 1 3 5
2 5 1 4 1 2 1 3 5
3 1 1 4 1 2 1 3 5
8 1 10 3 2 3 3 1 4 1
2 2 3 2 3 3 1 4 1
3 6 3 2 3 3 1 4 1
9 1 5 5 2 2 4 2 1 1
2 5 5 2 2 4 2 1 1
3 5 5 2 2 4 2 1 1
10 1 10 3 5 1 5 2 4 2
2 5 3 5 1 5 2 4 2
3 7 3 5 1 5 2 4 2
11 1 0 0 0 0 0 0 0 0
17 16 14 15 13 29 62
| Eagle | 1 | klorel/or-tools | examples/data/rcpsp/multi_mode_max_delay/mm_j10/psp175.sch | [
"Apache-2.0"
] |
{
"def": {
"enemySpottedMarker": {
"enabled": true,
"alpha": "{{a:spotted}}",
"x": 88,
"y": -2,
"align": "center",
"bindToIcon": true,
"format": "<font color='{{c:spotted}}'>{{spotted}}</font>",
"shadow": {}
},
"xmqpServiceMarker": {
"enabled": true,
"x": 88,
"y": -2,
"align": "center",
"bindToIcon": true,
"textFormat": {
"font": "xvm",
"size": 24
},
"format": "<font color='{{alive?{{x-spotted?#FFBB00|{{x-sense-on?#D9D9D9|#BFBFBF}}}}|#FFFFFF}}' alpha='{{alive?#FF|#80}}'>{{alive?{{x-spotted?p|{{x-sense-on?p|{{x-enabled?z}}}}}}}}</font>",
"shadow": {}
},
"clanIcon": {
"enabled": true,
"x": 65,
"y": 6,
"width": 16,
"height": 16,
"align": "center",
"alpha": 90,
"bindToIcon": true,
"src": "{{clanicon}}"
},
"xvmUserMarker": {
"enabled": false,
"x": 10,
"y": 5,
"bindToIcon": true,
"src": "xvm://res/icons/xvm/xvm-user-{{xvm-user|none}}.png"
},
"hpBarBg": {
"hotKeyCode": 56,
"onHold": "true",
"visibleOnHotKey": true,
"x": 96,
"y": 6,
"width": 72,
"bindToIcon": true,
"height": 14,
"bgColor": "0x000000",
"alpha": "{{alive?35|0}}"
},
"hpBar": {
"hotKeyCode": 56,
"onHold": "true",
"visibleOnHotKey": true,
"x": 97,
"y": 7,
"bindToIcon": true,
"width": "{{hp-ratio:70}}",
"height": 12,
"bgColor": "{{player?#FFDD33|{{c:system}}}}",
"alpha": "{{alive?50|0}}"
},
"hp": {
"hotKeyCode": 56,
"onHold": "true",
"visibleOnHotKey": true,
"bindToIcon": true,
"alpha": "{{alive?100|0}}",
"x": 96,
"width": 72,
"y": 4,
"textFormat": {
"font": "$FieldFont",
"size": 11,
"color": "0xD9D9D9",
"bold": "true",
"align": "center"
},
"format": "<font alpha='{{alive?{{ready?#FF|#80}}|#80}}'>{{alive?{{hp|{{l10n:No data}}}}|{{l10n:Destroyed}}}}</font>",
"shadow": {
"enabled": true,
"color": "0x000000",
"alpha": 100,
"blur": 4,
"strength": 1,
"distance": 0,
"angle": 0
}
},
"newDef": {
"isThisTheBestXvmParserEver": true
}
},
"playersPanel": {
"enabled": true,
"alpha": 80,
"iconAlpha": 100,
"removeSelectedBackground": false,
"removePanelsModeSwitcher": false,
"startMode": "large",
"altMode": null,
"none": {
"enabled": true,
"expandAreaWidth": 230,
"layout": "vertical",
"fixedPosition": false,
"inviteIndicatorAlpha": 100,
"inviteIndicatorX": 0,
"inviteIndicatorY": 0,
"extraFields": {
"leftPanel": {
"x": 0,
"y": 65,
"width": 350,
"height": 25,
"formats": []
},
"rightPanel": {
"x": 0,
"y": 65,
"width": 350,
"height": 25,
"formats": []
}
}
},
"short": {
"enabled": true,
"standardFields": [
"frags"
],
"expandAreaWidth": 230,
"removeSquadIcon": false,
"squadIconAlpha": 100,
"vehicleIconOffsetXLeft": 0,
"vehicleIconOffsetXRight": 0,
"vehicleLevelOffsetXLeft": 0,
"vehicleLevelOffsetXRight": 0,
"vehicleLevelAlpha": 100,
"fragsOffsetXLeft": 0,
"fragsOffsetXRight": 0,
"fragsWidth": 24,
"fragsFormatLeft": "{{frags}}",
"fragsFormatRight": "{{frags}}",
"fragsShadowLeft": null,
"fragsShadowRight": null,
"rankBadgeOffsetXLeft": 0,
"rankBadgeOffsetXRight": 0,
"rankBadgeWidth": 24,
"rankBadgeAlpha": "{{alive?100|70}}",
"nickOffsetXLeft": 0,
"nickOffsetXRight": 0,
"nickMinWidth": 46,
"nickMaxWidth": 158,
"nickFormatLeft": "<font face='mono' size='{{xvm-stat?13|0}}' color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{r}}</font> {{name%.15s~..}}<font alpha='#A0'>{{clan}}</font>",
"nickFormatRight": "<font alpha='#A0'>{{clan}}</font>{{name%.15s~..}} <font face='mono' size='{{xvm-stat?13|0}}' color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{r}}</font>",
"nickShadowLeft": null,
"nickShadowRight": null,
"vehicleOffsetXLeft": 0,
"vehicleOffsetXRight": 0,
"vehicleWidth": 72,
"vehicleFormatLeft": "{{vehicle}}",
"vehicleFormatRight": "{{vehicle}}",
"vehicleShadowLeft": null,
"vehicleShadowRight": null,
"fixedPosition": false,
"extraFieldsLeft": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.xmqpServiceMarker"}
],
"extraFieldsRight": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.enemySpottedMarker"}
]
},
"medium": {
"enabled": true,
"standardFields": [
"frags",
"badge",
"nick"
],
"expandAreaWidth": 230,
"removeSquadIcon": false,
"squadIconAlpha": 100,
"vehicleIconOffsetXLeft": 0,
"vehicleIconOffsetXRight": 0,
"vehicleLevelOffsetXLeft": 0,
"vehicleLevelOffsetXRight": 0,
"vehicleLevelAlpha": 100,
"fragsOffsetXLeft": 0,
"fragsOffsetXRight": 0,
"fragsWidth": 24,
"fragsFormatLeft": "{{frags}}",
"fragsFormatRight": "{{frags}}",
"fragsShadowLeft": null,
"fragsShadowRight": null,
"rankBadgeOffsetXLeft": 0,
"rankBadgeOffsetXRight": 0,
"rankBadgeWidth": 24,
"rankBadgeAlpha": "{{alive?100|70}}",
"nickOffsetXLeft": 0,
"nickOffsetXRight": 0,
"nickMinWidth": 46,
"nickMaxWidth": 158,
"nickFormatLeft": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{name%.12s~..}}</font> <font alpha='#A0'>{{clan}}</font>",
"nickFormatRight": "<font alpha='#A0'>{{clan}}</font> <font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{name%.12s~..}}</font>",
"nickShadowLeft": null,
"nickShadowRight": null,
"vehicleOffsetXLeft": 0,
"vehicleOffsetXRight": 0,
"vehicleWidth": 72,
"vehicleFormatLeft": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{vehicle}}</font>",
"vehicleFormatRight": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{vehicle}}</font>",
"vehicleShadowLeft": null,
"vehicleShadowRight": null,
"fixedPosition": false,
"extraFieldsLeft": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.xmqpServiceMarker"}
],
"extraFieldsRight": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.enemySpottedMarker"}
]
},
"medium2": {
"enabled": true,
"standardFields": [
"frags",
"vehicle"
],
"expandAreaWidth": 230,
"removeSquadIcon": false,
"squadIconAlpha": 100,
"vehicleIconOffsetXLeft": 0,
"vehicleIconOffsetXRight": 0,
"vehicleLevelOffsetXLeft": 0,
"vehicleLevelOffsetXRight": 0,
"vehicleLevelAlpha": 100,
"fragsOffsetXLeft": 0,
"fragsOffsetXRight": 0,
"fragsWidth": 24,
"fragsFormatLeft": "{{frags}}",
"fragsFormatRight": "{{frags}}",
"fragsShadowLeft": null,
"fragsShadowRight": null,
"rankBadgeOffsetXLeft": 0,
"rankBadgeOffsetXRight": 0,
"rankBadgeWidth": 24,
"rankBadgeAlpha": "{{alive?100|70}}",
"nickOffsetXLeft": 0,
"nickOffsetXRight": 0,
"nickMinWidth": 46,
"nickMaxWidth": 158,
"nickFormatLeft": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{name%.12s~..}}</font> <font alpha='#A0'>{{clan}}</font>",
"nickFormatRight": "<font alpha='#A0'>{{clan}}</font> <font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{name%.12s~..}}</font>",
"nickShadowLeft": null,
"nickShadowRight": null,
"vehicleOffsetXLeft": 0,
"vehicleOffsetXRight": 0,
"vehicleWidth": 72,
"vehicleFormatLeft": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{vehicle}}</font>",
"vehicleFormatRight": "<font color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{vehicle}}</font>",
"vehicleShadowLeft": null,
"vehicleShadowRight": null,
"fixedPosition": false,
"extraFieldsLeft": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.xmqpServiceMarker"}
],
"extraFieldsRight": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.enemySpottedMarker"}
]
},
"large": {
"enabled": true,
"standardFields": [
"frags",
"badge",
"nick",
"vehicle"
],
"removeSquadIcon": false,
"squadIconAlpha": 100,
"vehicleIconOffsetXLeft": 0,
"vehicleIconOffsetXRight": 0,
"vehicleLevelOffsetXLeft": 0,
"vehicleLevelOffsetXRight": 0,
"vehicleLevelAlpha": 100,
"fragsOffsetXLeft": 0,
"fragsOffsetXRight": 0,
"fragsWidth": 24,
"fragsFormatLeft": "{{frags}}",
"fragsFormatRight": "{{frags}}",
"fragsShadowLeft": null,
"fragsShadowRight": null,
"rankBadgeOffsetXLeft": 0,
"rankBadgeOffsetXRight": 0,
"rankBadgeWidth": 24,
"rankBadgeAlpha": "{{alive?100|70}}",
"nickOffsetXLeft": 0,
"nickOffsetXRight": 0,
"nickMinWidth": 46,
"nickMaxWidth": 158,
"nickFormatLeft": "<font face='mono' size='{{xvm-stat?13|0}}' color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{r|--}}</font> {{name%.{{xvm-stat?{{r_size>2?10|13}}|15}}s~..}}<font alpha='#A0'>{{clan}}</font>",
"nickFormatRight": "<font alpha='#A0'>{{clan}}</font>{{name%.{{xvm-stat?{{r_size>2?10|13}}|15}}s~..}} <font face='mono' size='{{xvm-stat?13|0}}' color='{{c:xr}}' alpha='{{alive?#FF|#80}}'>{{r}}</font>",
"nickShadowLeft": null,
"nickShadowRight": null,
"vehicleOffsetXLeft": 0,
"vehicleOffsetXRight": 0,
"vehicleWidth": 72,
"vehicleFormatLeft": "{{vehicle}}",
"vehicleFormatRight": "{{vehicle}}",
"vehicleShadowLeft": null,
"vehicleShadowRight": null,
"fixedPosition": false,
"extraFieldsLeft": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.xmqpServiceMarker"}
],
"extraFieldsRight": [
${"def.hpBarBg"},
${"def.hpBar"},
${"def.hp"},
${"def.clanIcon"},
${"def.xvmUserMarker"},
${"def.enemySpottedMarker"}
]
}
}
}
| XC | 3 | elektrosmoker/RelhaxModpack | RelhaxModpack/RelhaxUnitTests/bin/Debug/patch_regressions/followPath/check_06.xc | [
"Apache-2.0"
] |
onmessage = function (e) {
if (typeof self.Deno !== "undefined") {
throw new Error("Deno namespace unexpectedly available in worker");
}
postMessage(e.data);
};
| JavaScript | 3 | Preta-Crowz/deno | cli/tests/subdir/non_deno_worker.js | [
"MIT"
] |
#include <metal_stdlib>
#include "OperationShaderTypes.h"
using namespace metal;
typedef struct
{
float shadowTintIntensity;
float highlightTintIntensity;
float3 shadowTintColor;
float3 highlightTintColor;
} HighlightShadowTintUniform;
fragment half4 highlightShadowTintFragment(SingleInputVertexIO fragmentInput [[stage_in]],
texture2d<half> inputTexture [[texture(0)]],
constant HighlightShadowTintUniform& uniform [[ buffer(1) ]])
{
constexpr sampler quadSampler;
half4 color = inputTexture.sample(quadSampler, fragmentInput.textureCoordinate);
half luminance = dot(color.rgb, luminanceWeighting);
half4 shadowResult = mix(color, max(color, half4( mix(half3(uniform.shadowTintColor), color.rgb, luminance), color.a)), half(uniform.shadowTintIntensity));
half4 highlightResult = mix(color, min(shadowResult, half4( mix(shadowResult.rgb, half3(uniform.highlightTintColor), luminance), color.a)), half(uniform.highlightTintIntensity));
return half4(mix(shadowResult.rgb, highlightResult.rgb, luminance), color.a);
}
| Metal | 4 | luoxiao/GPUImage3 | framework/Source/Operations/HighlightAndShadowTint.metal | [
"BSD-3-Clause"
] |
// Copyright(c) 2022 https://github.com/WangXuan95
package Rv32iCPU;
import Vector::*;
import DReg::*;
import FIFOF::*;
import SpecialFIFOs::*;
import DFIFOF1::*;
// 枚举：指令码 OPCODE ---------------------------------------------------------------------------------------------
typedef enum { AUIPC = 7'b0010111, // U_TYPE rdst=pc+imm
LUI = 7'b0110111, // U_TYPE rdst=imm;
JAL = 7'b1101111, // J_TYPE rdst=pc+4, pc= pc+imm,
JALR = 7'b1100111, // I_TYPE rdst=pc+4, pc= rsrc1+imm
BRANCH = 7'b1100011, // B_TYPE conditional jump, pc= pc+imm,
ALI = 7'b0010011, // I_TYPE arithmetic&logical, rdst = alu(rsrc1, imm)
ALR = 7'b0110011, // R_TYPE arithmetic&logical, rdst = alu(rsrc1, rsrc2)
LOAD = 7'b0000011, // I_TYPE load, rdst=mem_load
STORE = 7'b0100011, // S_TYPE store
UNKNOWN = 7'b0
} OpCode deriving(Bits, Eq);
// 结构体：寄存器有效、地址、数据 ---------------------------------------------------------------------------------------------
typedef struct {
Bool e;
Bit#(5) a;
Bit#(32) d;
} RegItem deriving(Bits);
// 结构体：指令解码和执行结果 ---------------------------------------------------------------------------------------------
typedef struct { //struction of Decoded Instrunction item, named InstrItem.
Bit#(32) pc; // fill at IF stage
OpCode opcode; // fill at ID stage
RegItem rsrc1; // fill at ID stage
RegItem rsrc2; // fill at ID stage
RegItem rdst; // rdst.e , rdst.a fill at ID stage. rdst.d fill at EX stage
Bit#(7) funct7; // fill at ID stage
Bit#(3) funct3; // fill at ID stage
Bool store; // fill at ID stage
Bool load; // fill at ID stage
Bit#(32) immu; // fill at ID stage
} InstrItem deriving(Bits);
// 接口： CPU 的接口 ---------------------------------------------------------------------------------------------
interface CPU_ifc;
method Action boot(Bit#(32) boot_addr); // CPU boot
method Bit#(32) ibus_req; // instruction-bus request, return addr (i.e. PC)
method Action ibus_reqx; // instruction-bus request ready
method Action ibus_resp(Bit#(32) rdata); // instruction-bus response, parameter is rdata (i.e. instruction)
method Tuple4#(Bool, Bit#(4), Bit#(32), Bit#(32)) dbus_req; // data-bus request, return (is_write?, byte_en, addr, wdata)
method Action dbus_reqx; // data-bus request ready
method Action dbus_resp(Bit#(32) rdata); // data-bus response rdata, parameter is rdata (only response when is_write=False)
endinterface
// 模块： CPU 的实现
//
// 支持 ： 基本完备的 RV32I 指令集
// EX阶段和WB阶段的寄存器结果bypass到ID阶段
// instruction-bus 和 data-bus 的握手与停顿 （例如能应对 cache-miss）
//
// 不支持: CSR 类指令
// 单字节、双字节 Load 和 Store，只支持四字节 Load 和 Store。
//
(* synthesize *)
(* always_ready = "boot" *)
module mkRv32iCPU (CPU_ifc);
// 函数：指令解码 ---------------------------------------------------------------------------------------------
// 用在 ID段
function InstrItem decode(Bit#(32) instr);
InstrItem item = unpack('0);
item.funct7 = instr[31:25];
item.rsrc2.a = instr[24:20];
item.rsrc1.a = instr[19:15];
item.funct3 = instr[14:12];
item.rdst.a = instr[11:7];
item.opcode = unpack(instr[6:0]);
item.store = item.opcode == STORE;
item.load = item.rdst.a != 0 && item.opcode == LOAD;
item.rdst.e = item.rdst.a != 0 && (item.opcode == LOAD || item.opcode == JAL || item.opcode == JALR || item.opcode == LUI || item.opcode == AUIPC || item.opcode == ALI || item.opcode == ALR );
item.rsrc2.e = item.opcode == ALR || item.opcode == STORE || item.opcode == BRANCH;
item.rsrc1.e = item.opcode == ALI || item.opcode == LOAD || item.opcode == JALR || item.rsrc2.e;
int imms = case(item.opcode)
AUIPC : return unpack({instr[31:12], 12'h0}); // U_TYPE
LUI : return unpack({instr[31:12], 12'h0}); // U_TYPE
ALI : return extend(unpack(instr[31:20])); // I_TYPE
LOAD : return extend(unpack(instr[31:20])); // I_TYPE
JALR : return extend(unpack(instr[31:20])); // I_TYPE
STORE : return extend(unpack({instr[31:25], instr[11:7]})); // S_TYPE
BRANCH : return extend(unpack({instr[31], instr[7], instr[30:25], instr[11:8], 1'b0})); // B_TYPE
JAL : return extend(unpack({instr[31], instr[19:12], instr[20], instr[30:21], 1'b0})); // J_TYPE
default: return 0;
endcase;
item.immu = pack(imms);
return item;
endfunction
// 函数：判断 BRANCH 类指令是否跳转 ---------------------------------------------------------------------------------------------
// 用在 EX段
function Bool is_branch(InstrItem item);
int item_rsrc1_s = unpack(item.rsrc1.d);
int item_rsrc2_s = unpack(item.rsrc2.d);
return case(item.funct3)
3'b000 : return item.rsrc1.d == item.rsrc2.d; // BEQ
3'b001 : return item.rsrc1.d != item.rsrc2.d; // BNE
3'b100 : return item_rsrc1_s < item_rsrc2_s; // BLT
3'b101 : return item_rsrc1_s >= item_rsrc2_s; // BGE
3'b110 : return item.rsrc1.d < item.rsrc2.d; // BLTU
3'b111 : return item.rsrc1.d >= item.rsrc2.d; // BGEU
default: return False;
endcase;
endfunction
// 函数：ALU，得到算术逻辑计算结果 ---------------------------------------------------------------------------------------------
// 用在 EX段
function Bit#(32) alu(InstrItem item);
Bit#(5) shamti = truncate(item.immu);
Bit#(5) shamtr = truncate(item.rsrc2.d);
int item_rsrc1_s = unpack(item.rsrc1.d);
int item_rsrc2_s = unpack(item.rsrc2.d);
int imms = unpack(item.immu);
return case( {item.funct7, item.funct3, pack(item.opcode)} ) matches
17'b???????_???_110?111 : return item.pc + 4; // JAL, JALR
17'b???????_???_0110111 : return item.immu; // LUI
17'b???????_???_0010111 : return item.pc + item.immu; // AUIPC
17'b0000000_000_0110011 : return item.rsrc1.d + item.rsrc2.d; // ADD
17'b???????_000_0010011 : return item.rsrc1.d + item.immu; // ADDI
17'b0100000_000_0110011 : return item.rsrc1.d - item.rsrc2.d; // SUB
17'b0000000_100_0110011 : return item.rsrc1.d ^ item.rsrc2.d; // XOR
17'b???????_100_0010011 : return item.rsrc1.d ^ item.immu; // XORI
17'b0000000_110_0110011 : return item.rsrc1.d | item.rsrc2.d; // OR
17'b???????_110_0010011 : return item.rsrc1.d | item.immu; // ORI
17'b0000000_111_0110011 : return item.rsrc1.d & item.rsrc2.d; // AND
17'b???????_111_0010011 : return item.rsrc1.d & item.immu; // ANDI
17'b0000000_001_0110011 : return item.rsrc1.d << shamtr; // SLL
17'b0000000_001_0010011 : return item.rsrc1.d << shamti; // SLLI
17'b0000000_101_0110011 : return item.rsrc1.d >> shamtr; // SRL
17'b0000000_101_0010011 : return item.rsrc1.d >> shamti; // SRL
17'b0100000_101_0110011 : return unpack(pack(item_rsrc1_s >> shamtr)); // SRA
17'b0100000_101_0010011 : return unpack(pack(item_rsrc1_s >> shamti)); // SRAI
17'b0000000_010_0110011 : return (item_rsrc1_s < item_rsrc2_s) ? 1 : 0; // SLT
17'b???????_010_0010011 : return (item_rsrc1_s < imms ) ? 1 : 0; // SLTI
17'b0000000_011_0110011 : return (item.rsrc1.d < item.rsrc2.d) ? 1 : 0; // SLTU
17'b???????_011_0010011 : return (item.rsrc1.d < item.immu ) ? 1 : 0; // SLTIU
default : return 0;
endcase;
endfunction
// 函数：dbus_adapt_req，对读写请求进行访存转换（构建读写请求） ---------------------------------------------------------------------------------------------
// 用在 EX段
function Tuple4#(Bool, Bit#(4), Bit#(32), Bit#(32)) dbus_adapt_req(InstrItem item);
Bit#(4) byte_en = 0;
Bit#(32) addr = item.rsrc1.d + item.immu;
Bit#(32) wdata = item.rsrc2.d;
if(item.store)
case (item.funct3) matches
3'b?00 : begin byte_en = 'b0001 << addr[1:0]; wdata = wdata << {addr[1:0],3'd0}; end
3'b?01 : begin byte_en = 'b0011 << addr[1:0]; wdata = wdata << {addr[1:0],3'd0}; end
default: byte_en = 'b1111;
endcase
return tuple4(item.store, byte_en, (addr>>2<<2), wdata);
endfunction
// 函数：dbus_adapt_rdata，对读响应进行访存转换 ---------------------------------------------------------------------------------------------
// 用在 EX段
function Bit#(32) dbus_adapt_rdata(InstrItem item, Bit#(32) rdata);
Bit#(32) addr = item.rsrc1.d + item.immu;
Bit#(5) shamt = {addr[1:0],3'd0};
return case (item.funct3) matches
3'b000 : return signExtend( (rdata>>shamt)[ 7:0] );
3'b100 : return zeroExtend( (rdata>>shamt)[ 7:0] );
3'b001 : return signExtend( (rdata>>shamt)[15:0] );
3'b101 : return zeroExtend( (rdata>>shamt)[15:0] );
default: return rdata;
endcase;
endfunction
// Register file 32bit*32 ---------------------------------------------------------------------------------------------
Vector#(32, Reg#(Bit#(32))) regfile <- replicateM( mkReg(0) );
// To get the Next PC ---------------------------------------------------------------------------------------------
Reg#(Maybe#(Bit#(32))) boot_pc <- mkDReg(tagged Invalid);
FIFOF#(Bit#(32)) if_pc <- mkSizedBypassFIFOF(2);
FIFOF#(Bit#(32)) id_pc <- mkFIFOF;
FIFOF#(Bit#(32)) id_instr <- mkBypassFIFOF;
FIFOF#(InstrItem) ex <- mkDFIFOF(unpack('0));
Reg#(RegItem) wb <- mkDReg(unpack('0));
FIFOF#(InstrItem) ld <- mkDFIFOF1(unpack('0));
FIFOF#(Tuple4#(Bool, Bit#(4), Bit#(32), Bit#(32))) lsq <- mkBypassFIFOF;
(* conflict_free = "ex_stage, id_stage" *)
(* descending_urgency = "enq_boot_pc, ex_stage" *)
(* descending_urgency = "enq_boot_pc, id_stage" *)
(* mutually_exclusive = "dbus_resp, wb_stage" *)
// 2. ID (Instruction Decode) stage -----------------------------------------------------------------
rule id_stage;
InstrItem item = decode(id_instr.first);
item.pc = id_pc.first;
// register bypass read logic
item.rsrc1.d = (item.rsrc1.e && wb.e && item.rsrc1.a == wb.a) ? wb.d : regfile[item.rsrc1.a];
item.rsrc2.d = (item.rsrc2.e && wb.e && item.rsrc2.a == wb.a) ? wb.d : regfile[item.rsrc2.a];
// If there's no hazard, push this instruction to EX stage
if( !( ld.first.load && (item.rsrc1.e && item.rsrc1.a == ld.first.rdst.a || item.rsrc2.e && item.rsrc2.a == ld.first.rdst.a) ) && // NO hazard with wb_stage
!( ex.first.rdst.e && (item.rsrc1.e && item.rsrc1.a == ex.first.rdst.a || item.rsrc2.e && item.rsrc2.a == ex.first.rdst.a) ) ) begin // NO hazard with ex_stage
id_instr.deq;
id_pc.deq;
ex.enq(item);
if(item.opcode != JALR && item.opcode != BRANCH)
if_pc.enq( item.opcode==JAL ? item.pc+item.immu : item.pc+4 );
end
endrule
// 3. EX&MEM (Execute and Memory Access) stage -----------------------------------------------------------------
rule ex_stage;
ex.deq;
InstrItem item = ex.first;
case( item.opcode )
JALR : if_pc.enq( item.rsrc1.d + item.immu );
BRANCH : if_pc.enq( item.pc + (is_branch(item) ? item.immu : 4) );
endcase
if(item.store || item.load) begin
lsq.enq( dbus_adapt_req(item) );
if(item.load)
ld.enq(item);
end else begin
item.rdst.d = alu(item);
wb <= item.rdst;
end
endrule
// 4. WB (Register Write Back) stage -----------------------------------------------------------------
rule wb_stage (wb.e);
regfile[wb.a] <= wb.d;
endrule
rule enq_boot_pc (isValid(boot_pc));
if_pc.enq( fromMaybe(0, boot_pc) );
endrule
// CPU boot -----------------------------------------------------------------------------------------------------------------------------------------
method Action boot(Bit#(32) boot_addr);
boot_pc <= tagged Valid boot_addr;
endmethod
// instr bus interface (methods) -------------------------------------------------------------------------------------------------------------------------------
method ibus_req = if_pc.first;
method Action ibus_reqx;
if_pc.deq;
id_pc.enq(if_pc.first);
endmethod
method ibus_resp = id_instr.enq;
// data bus interface (methods) -------------------------------------------------------------------------------------------------------------------------------
method dbus_req = lsq.first;
method dbus_reqx = lsq.deq;
method Action dbus_resp(Bit#(32) rdata) if(ld.first.load);
ld.deq;
regfile[ld.first.rdst.a] <= dbus_adapt_rdata(ld.first, rdata);
endmethod
endmodule
endpackage
| Bluespec | 5 | Xiefengshang/BSV_Tutorial_cn | src/Rv32iCPU/Rv32iCPU.bsv | [
"MIT"
] |
Note 0
Copyright (C) 2017 Jonathan Hough. All rights reserved.
)
NB. Radial Basis Function Networks for Classification and Regression.
load jpath '~Projects/jlearn/clustering/kmeans.ijs'
coclass 'RBFBase'
dot=: +/ . *
pinv=: |: dot~ %.@:(|: dot ])
create=: codestroy
NB. Radial Basis Function Network for classification implementation.
NB.
NB. Example usage:
NB. rbf =: (input;target;10) conew 'RBFClassifier'
NB. input and target are the input and target arrays, resp.
NB. The third parameter is the number of basis functions to use.
NB.
NB. fit__rbf ''
NB. This will train the RBF-network's weight matrices (input-hidden weights,
NB. and hidden-output weights).
NB.
NB. predict__rbf"1 testdata
NB. This will tes tthe network's accuracy and give the output for each row
NB. of the test input values, testdata.
coclass 'RBFClassifier'
coinsert 'RBFBase'
NB. Create a new instance of the RBF Network Classifier.
NB. Parameters:
NB. 0: input dataset
NB. 1: target data for the input dataset
NB. 2: Number of nodes to use in the hidden layer.
NB. 3: Multiplier for the radial basis function exponent.
create=: 3 : 0
'inputs targets nRBF multiplier'=: y
assert. nRBF > 0
assert. multiplier > 0
weights1=: (nRBF ? 0{ $ inputs) { inputs NB. in-hidden weights
weights2=: '' NB. hidden-out weights
gbf=: ^@:(+/"1) @:(*&multiplier)@:-@:*:@:- NB. gaussian basis fn
''
)
NB. Trains the RBF network. Take a subsample of the training
NB. data.
fit=: 3 : 0
hidden=: 1,~"1 inputs gbf"1 1"1 _ weights1
NB. use the pseudoinverse of the hidden matrix
NB. to get the output weight matrix.
weights2=: ( pinv hidden) dot targets
''
)
NB. Predict the output given some test input data.
NB. Parameters:
NB. 0: test datapoints to predict the output values for.
predict=: 3 : 0 "_
(1,~"1 y gbf"1 1"1 _ weights1) dot weights2
)
NB. Gives an score of the neural net, based on its
NB. accuracy on estimating the results for the given
NB. test data.
NB. x: test data target values
NB. y: test data input set
NB. returns:
NB. score in range [0,1], where 1 is perfect
NB. accuracy.
score=: 4 : 0 "_
assert. x (-:&:({.@:$)) y
vdata=. predict y
(# y) %~ +/x -:"1 1 (=>./)"1 vdata
)
getAvgError=: 4 : 0
vdata=. validate y
(+/ % #) | , x -"1 1 vdata
)
destroy=: codestroy
NB. Radial Basis Function Network Regressor.
coclass 'RBFRegressor'
coinsert 'RBFBase'
NB. Create a new instance of the RBF Network Regressor.
NB. Parameters:
NB. 0: input dataset
NB. 1: target data for the input dataset
NB. 2: Number of nodes to use in the hidden layer.
NB. 3: Multiplier for the radial basis function exponent.
NB.
NB. Example:
NB. > NB. X,y are training set, targets
NB. > NB. Z,t are test set and target
NB. > rbfr=: (X;y;100;4.5) conew 'RBFRegressor'
NB. > fit__rbfr ''
NB. > load 'plot' NB. plot test results against learned test results
NB. > plot |: t ,. predict__rbfr Z
NB.
create=: 3 : 0
'inputs targets nRBF multiplier'=: y
'Input data must be 2 dimensional.' assert 2=$inputs
'Target data must be 2 dimensional.' assert 2=$targets
assert. nRBF > 0
assert. multiplier > 0
weights1=: (nRBF ? 0{ $ inputs) { inputs NB. in-hidden weights
weights2=: '' NB. hidden-out weights
gbf=: ^@:(+/"1) @:(*&multiplier)@:-@:*:@:- NB. gaussian basis fn
''
)
NB. Trains the RBF network. Take a subsample of the training
NB. data.
fit=: 3 : 0
hidden=: 1,~"1 inputs gbf"1 1"1 _ weights1
weights2=: ( pinv hidden) dot targets
''
)
NB. Predict the target values for the given input, based
NB. on the trained RBF network.
predict=: 3 : 0 "_
(1,~"1 y gbf"1 1"1 _ weights1) dot weights2
)
destroy=: codestroy | J | 5 | jonghough/jlearn | rbf/rbf.ijs | [
"MIT"
] |
====================
eCAL @(ecal_version)
====================
- Release Date: @(gh_release.published_at.strftime("%Y-%m-%d"))
- GitHub Release Page: @(gh_release.html_url)
@{
changelog = gh_release.body
changelog = changelog.replace('\\n', '\n')
}@
@[if changelog_file != ""]@
Changelog
=========
.. literalinclude:: @(changelog_file)
:language: txt
@[end if]@
Downloads
=========
.. raw:: html
:file: @(download_table_html_file) | EmberScript | 3 | SirArep/ecal | doc/extensions/resource/download_archive_page.rst.em | [
"Apache-2.0"
] |
{ lib, buildPythonPackage, fetchFromGitHub, isPy27
, bleach
, mt-940
, requests
, sepaxml
, pytestCheckHook
, pytest-mock
}:
buildPythonPackage rec {
version = "3.0.1";
pname = "fints";
disabled = isPy27;
src = fetchFromGitHub {
owner = "raphaelm";
repo = "python-fints";
rev = "v${version}";
sha256 = "sha256-P9+3QuB5c7WMjic2fSp8pwXrOUHIrLThvfodtbBXLMY=";
};
propagatedBuildInputs = [ requests mt-940 sepaxml bleach ];
checkInputs = [ pytestCheckHook pytest-mock ];
meta = with lib; {
homepage = "https://github.com/raphaelm/python-fints/";
description = "Pure-python FinTS (formerly known as HBCI) implementation";
license = licenses.lgpl3Only;
maintainers = with maintainers; [ elohmeier dotlambda ];
};
}
| Nix | 4 | collinwright/nixpkgs | pkgs/development/python-modules/fints/default.nix | [
"MIT"
] |
.example-accordion {
display: block;
max-width: 500px;
}
.example-accordion-item {
display: block;
border: solid 1px #ccc;
}
.example-accordion-item + .example-accordion-item {
border-top: none;
}
.example-accordion-item-header {
display: flex;
align-content: center;
justify-content: space-between;
}
.example-accordion-item-description {
font-size: 0.85em;
color: #999;
}
.example-accordion-item-header,
.example-accordion-item-body {
padding: 16px;
}
.example-accordion-item-header:hover {
cursor: pointer;
background-color: #eee;
}
.example-accordion-item:first-child {
border-top-left-radius: 4px;
border-top-right-radius: 4px;
}
.example-accordion-item:last-child {
border-bottom-left-radius: 4px;
border-bottom-right-radius: 4px;
}
| CSS | 4 | tungyingwaltz/components | src/components-examples/cdk/accordion/cdk-accordion-overview/cdk-accordion-overview-example.css | [
"MIT"
] |
#ifndef CAFFE2_UTILS_THREADPOOL_COMMON_H_
#define CAFFE2_UTILS_THREADPOOL_COMMON_H_
#ifdef __APPLE__
#include <TargetConditionals.h>
#endif
// caffe2 depends upon NNPACK, which depends upon this threadpool, so
// unfortunately we can't reference core/common.h here
// This is copied from core/common.h's definition of C10_MOBILE
// Define enabled when building for iOS or Android devices
#if defined(__ANDROID__)
#define C10_ANDROID 1
#elif (defined(__APPLE__) && \
(TARGET_IPHONE_SIMULATOR || TARGET_OS_SIMULATOR || TARGET_OS_IPHONE))
#define C10_IOS 1
#endif // ANDROID / IOS
#endif // CAFFE2_UTILS_THREADPOOL_COMMON_H_
| C | 4 | Hacky-DH/pytorch | caffe2/utils/threadpool/ThreadPoolCommon.h | [
"Intel"
] |
{% set result = 9999999999 | random_hash() %}
{% include 'jinja_filters/common.sls' %}
| SaltStack | 2 | byteskeptical/salt | tests/integration/files/file/base/jinja_filters/hashutils_random_hash.sls | [
"Apache-2.0"
] |
ENTRY(thorRtEntry)
SECTIONS {
/* This address is dictated by System V ABI's kernel code model. */
. = 0xFFFFFFFF80000000;
stubsPtr = .;
.text.stubs : {
*(.text.stubs)
}
stubsLimit = .;
.text : { *(.text .text.*) }
.rodata : { *(.rodata .rodata.*) }
.eh_frame_hdr : { *(.eh_frame_hdr) }
.eh_frame : { *(.eh_frame) }
. = ALIGN(0x1000);
.init_array : {
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.data : { *(.data) }
.bss : { *(.bss) }
}
| Logos | 3 | kITerE/managarm | kernel/thor/arch/x86/link.x | [
"MIT"
] |
discard """
errormsg: "illegal recursion in type 'Weird'"
"""
# issue #3456
import tables
type
Weird = ref seq[Weird]
var t = newTable[int, Weird]()
| Nimrod | 2 | JohnAD/Nim | tests/types/tillegaltyperecursion3.nim | [
"MIT"
] |
rhack(1)
# NAME
rhack - easily edit external crates that your Rust project depends on.
# SYNOPSIS
*rhack* <package name>
# EDITING
To check out a local copy of your dependency run:
*rhack* <package name>
This will make a copy of the crate in your _RHACK_DIR_, and patch your
*Cargo.toml*.
For example running *rhack reqwest* might result in a local copy
at _~/.rhack/reqwest-0.11.1_, and an amendment to your *Cargo.toml* like this:
\[patch.crates-io\]++
reqwest = { path = "/home/you/.rhack/reqwest-0.11.1" }
# UNDO
To remove changes made by *rhack* to *Cargo.toml*, run:
*rhack undo*
This will _not_ remove any copies of crates in your _RHACK_DIR_.
# CONFIGURATION
rhack stores copies of crates in the directory specified by the _RHACK_DIR_
environment variable.
Where this is unset, the default is _$HOME/.rhack_
# AUTHORS
Ryo Nakao <[email protected]>
# PROJECT HOMEPAGE
Sources can be found, and bugs or patches submitted at https://github.com/nakabonne/rhack
| SuperCollider | 4 | SirWindfield/rhack | rhack.1.scd | [
"BSD-3-Clause"
] |
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>How Many Demos Do You Need</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>
.demo4 {
display: flex;
display: -webkit-flex;
align-items: center;
height: 700px;
position: relative;
}
.demo4-inner {
overflow: hidden;
position: relative;
margin: auto;
}
.demo4-photo {
position: absolute;
background-color: lightgray;
}
</style>
</head>
<body>
<div id="content"></div>
<script src="./all.js"></script>
</body>
</html>
| HTML | 3 | jsm1003/react-motion | demos/demo4-photo-gallery/index.html | [
"MIT"
] |
fileFormatVersion: 2
guid: 56c88c70f2044f74dae91724d10cd93c
folderAsset: yes
timeCreated: 1477156499
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
| Unity3D Asset | 0 | Jhinhx/ET | Unity/Assets/Editor/RsyncEditor.meta | [
"MIT"
] |
get:
description: Get info about the Marathon Instance
responses:
200:
description: General configuration and runtime information about this Marathon instance.
body:
application/json:
type: info.MarathonInfo
example: !include examples/info.json
| RAML | 4 | fquesnel/marathon | docs/docs/rest-api/public/api/v2/info.raml | [
"Apache-2.0"
] |
From https://github.com/stevenrskelton/flag-icon | Markdown | 4 | asahiocean/joplin | Assets/WebsiteAssets/images/flags/README.md | [
"MIT"
] |
--TEST--
SimpleXML [interop]: simplexml_import_dom
--EXTENSIONS--
simplexml
dom
--FILE--
<?php
$dom = new domDocument;
$dom->load(__DIR__."/book.xml");
if(!$dom) {
echo "Error while parsing the document\n";
exit;
}
$s = simplexml_import_dom($dom);
$books = $s->book;
foreach ($books as $book) {
echo "{$book->title} was written by {$book->author}\n";
}
?>
--EXPECT--
The Grapes of Wrath was written by John Steinbeck
The Pearl was written by John Steinbeck
| PHP | 4 | NathanFreeman/php-src | ext/simplexml/tests/simplexml_import_dom.phpt | [
"PHP-3.01"
] |
-@ val script1: String
-@ val script2: String
-@ val googleAnalyticsScript: String
-@ val pv: lv.ddgatve.math.ProblemVideo
-@ val lang: String
-@ val localizationStrings: lv.ddgatve.math.LocalizationStrings
-@ val indexFile: String
-@ val topMenu: Map[String,String]
-@ val menuKeys: List[String]
-@ val lvamoMap: scala.collection.immutable.TreeMap[String,String]
-@ val lvsolMap: scala.collection.immutable.TreeMap[String,String]
%html
%head
%title Math Olympiads: Problem Solutions</title>
%meta{"http-equiv"=>"content-type", :content=>"text/html;charset=utf-8"}
%link{:rel=>"stylesheet", :type=>"text/css", :href=>"style1.css"}
%script{:type=>"text/javascript", :src=>"http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"}
%script{:type=>"text/javascript", :src=>"http://ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js"}
%script{:type=>"text/javascript"} = unescape(script1)
%script{:type=>"text/javascript"} = unescape(script2)
%body
- render("nav.scaml")
%p
%a{:href=>{"http://www.dudajevagatve.lv/math/" + indexFile}}
= localizationStrings.listOfProblems(lang)
%h1 = pv.title
%div{:class=>"problem"} = unescape(pv.description)
%br
%table
%tr
%td
%div{:id=>"ytapiplayer"} You need Flash player 8+ and JavaScript enabled to view this video.
%td
- for (i <- 0 to (pv.chunkListTitles.size-1))
%div{:class=>"line"}
%b = pv.chunkListTitles(i)
- for (j <- 0 to (pv.chunkLists(i).size - 1))
%div{:class=>"indentedLine"}
%span = "(" + (97 + j).toChar + ") " + pv.chunkLists(i)(j).tstamp
%a{:href=>"#", :onclick => {"playerSeekTo(ytplayer," + pv.chunkLists(i)(j).getSeconds + "); return false;"} }
= pv.chunkLists(i)(j).text
- if (pv.notes.size > 0)
%h4 = localizationStrings.notes(lang)
%ol
- for (note <- pv.notes)
%li = unescape(note)
%p
%b = localizationStrings.references(lang)
%a{:href=>"http://nms.lu.lv/uzdevumu-arhivs/latvijas-olimpiades/"}
= localizationStrings.problemArchive(lang)
%script = unescape(googleAnalyticsScript)
| Scaml | 3 | kapsitis/ddgatve-stat | src/main/resources/youtube-topics.scaml | [
"Apache-2.0"
] |
<?xml version="1.0" encoding="UTF-8"?>
<!-- tag::caches[] -->
<project>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<image>
<buildCache>
<volume>
<name>cache-${project.artifactId}.build</name>
</volume>
</buildCache>
<launchCache>
<volume>
<name>cache-${project.artifactId}.launch</name>
</volume>
</launchCache>
</image>
</configuration>
</plugin>
</plugins>
</build>
</project>
<!-- end::caches[] --> | XML | 2 | techAi007/spring-boot | spring-boot-project/spring-boot-tools/spring-boot-maven-plugin/src/docs/maven/packaging-oci-image/caches-pom.xml | [
"Apache-2.0"
] |
# Copyright 1999-2018 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# @ECLASS: eutils.eclass
# @MAINTAINER:
# [email protected]
# @BLURB: many extra (but common) functions that are used in ebuilds
# @DESCRIPTION:
# The eutils eclass contains a suite of functions that complement
# the ones that ebuild.sh already contain. The idea is that the functions
# are not required in all ebuilds but enough utilize them to have a common
# home rather than having multiple ebuilds implementing the same thing.
#
# Due to the nature of this eclass, some functions may have maintainers
# different from the overall eclass!
if [[ -z ${_EUTILS_ECLASS} ]]; then
_EUTILS_ECLASS=1
# implicitly inherited (now split) eclasses
case ${EAPI:-0} in
0|1|2|3|4|5|6)
inherit desktop epatch estack ltprune multilib preserve-libs \
toolchain-funcs vcs-clean
;;
esac
# @FUNCTION: emktemp
# @USAGE: [temp dir]
# @DESCRIPTION:
# Cheap replacement for when debianutils (and thus mktemp)
# does not exist on the users system.
emktemp() {
local exe="touch"
[[ $1 == -d ]] && exe="mkdir" && shift
local topdir=$1
if [[ -z ${topdir} ]] ; then
[[ -z ${T} ]] \
&& topdir="/tmp" \
|| topdir=${T}
fi
if ! type -P mktemp > /dev/null ; then
# system lacks `mktemp` so we have to fake it
local tmp=/
while [[ -e ${tmp} ]] ; do
tmp=${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}
done
${exe} "${tmp}" || ${exe} -p "${tmp}"
echo "${tmp}"
else
# the args here will give slightly wierd names on BSD,
# but should produce a usable file on all userlands
if [[ ${exe} == "touch" ]] ; then
TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
else
TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
fi
fi
}
# @FUNCTION: edos2unix
# @USAGE: <file> [more files ...]
# @DESCRIPTION:
# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
# to remove all of these text utilities from DEPEND variables because this
# is a script based solution. Just give it a list of files to convert and
# they will all be changed from the DOS CRLF format to the UNIX LF format.
edos2unix() {
[[ $# -eq 0 ]] && return 0
sed -i 's/\r$//' -- "$@" || die
}
# @FUNCTION: strip-linguas
# @USAGE: [<allow LINGUAS>|<-i|-u> <directories of .po files>]
# @DESCRIPTION:
# Make sure that LINGUAS only contains languages that
# a package can support. The first form allows you to
# specify a list of LINGUAS. The -i builds a list of po
# files found in all the directories and uses the
# intersection of the lists. The -u builds a list of po
# files found in all the directories and uses the union
# of the lists.
strip-linguas() {
local ls newls nols
if [[ $1 == "-i" ]] || [[ $1 == "-u" ]] ; then
local op=$1; shift
ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
local d f
for d in "$@" ; do
if [[ ${op} == "-u" ]] ; then
newls=${ls}
else
newls=""
fi
for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
if [[ ${op} == "-i" ]] ; then
has ${f} ${ls} && newls="${newls} ${f}"
else
has ${f} ${ls} || newls="${newls} ${f}"
fi
done
ls=${newls}
done
else
ls="$@"
fi
nols=""
newls=""
for f in ${LINGUAS} ; do
if has ${f} ${ls} ; then
newls="${newls} ${f}"
else
nols="${nols} ${f}"
fi
done
[[ -n ${nols} ]] \
&& einfo "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
export LINGUAS=${newls:1}
}
# @FUNCTION: make_wrapper
# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
# @DESCRIPTION:
# Create a shell wrapper script named wrapper in installpath
# (defaults to the bindir) to execute target (default of wrapper) by
# first optionally setting LD_LIBRARY_PATH to the colon-delimited
# libpaths followed by optionally changing directory to chdir.
make_wrapper() {
local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
local tmpwrapper=$(emktemp)
has "${EAPI:-0}" 0 1 2 && local EPREFIX=""
(
echo '#!/bin/sh'
if [[ -n ${libdir} ]] ; then
local var
if [[ ${CHOST} == *-darwin* ]] ; then
var=DYLD_LIBRARY_PATH
else
var=LD_LIBRARY_PATH
fi
cat <<-EOF
if [ "\${${var}+set}" = "set" ] ; then
export ${var}="\${${var}}:${EPREFIX}${libdir}"
else
export ${var}="${EPREFIX}${libdir}"
fi
EOF
fi
[[ -n ${chdir} ]] && printf 'cd "%s" &&\n' "${EPREFIX}${chdir}"
# We don't want to quote ${bin} so that people can pass complex
# things as ${bin} ... "./someprog --args"
printf 'exec %s "$@"\n' "${bin/#\//${EPREFIX}/}"
) > "${tmpwrapper}"
chmod go+rx "${tmpwrapper}"
if [[ -n ${path} ]] ; then
(
exeopts -m 0755
exeinto "${path}"
newexe "${tmpwrapper}" "${wrapper}"
) || die
else
newbin "${tmpwrapper}" "${wrapper}" || die
fi
}
path_exists() {
eerror "path_exists has been removed. Please see the following post"
eerror "for a replacement snippet:"
eerror "https://blogs.gentoo.org/mgorny/2018/08/09/inlining-path_exists/"
die "path_exists is banned"
}
# @FUNCTION: use_if_iuse
# @USAGE: <flag>
# @DESCRIPTION:
# Return true if the given flag is in USE and IUSE.
#
# Note that this function should not be used in the global scope.
use_if_iuse() {
in_iuse $1 || return 1
use $1
}
# @FUNCTION: optfeature
# @USAGE: <short description> <package atom to match> [other atoms]
# @DESCRIPTION:
# Print out a message suggesting an optional package (or packages)
# not currently installed which provides the described functionality.
#
# The following snippet would suggest app-misc/foo for optional foo support,
# app-misc/bar or app-misc/baz[bar] for optional bar support
# and either both app-misc/a and app-misc/b or app-misc/c for alphabet support.
# @CODE
# optfeature "foo support" app-misc/foo
# optfeature "bar support" app-misc/bar app-misc/baz[bar]
# optfeature "alphabet support" "app-misc/a app-misc/b" app-misc/c
# @CODE
optfeature() {
debug-print-function ${FUNCNAME} "$@"
local i j msg
local desc=$1
local flag=0
shift
for i; do
for j in ${i}; do
if has_version "${j}"; then
flag=1
else
flag=0
break
fi
done
if [[ ${flag} -eq 1 ]]; then
break
fi
done
if [[ ${flag} -eq 0 ]]; then
for i; do
msg=" "
for j in ${i}; do
msg+=" ${j} and"
done
msg="${msg:0: -4} for ${desc}"
elog "${msg}"
done
fi
}
case ${EAPI:-0} in
0|1|2)
# @FUNCTION: epause
# @USAGE: [seconds]
# @DESCRIPTION:
# Sleep for the specified number of seconds (default of 5 seconds). Useful when
# printing a message the user should probably be reading and often used in
# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set,
# don't wait at all. Defined in EAPIs 0 1 and 2.
epause() {
[[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
}
# @FUNCTION: ebeep
# @USAGE: [number of beeps]
# @DESCRIPTION:
# Issue the specified number of beeps (default of 5 beeps). Useful when
# printing a message the user should probably be reading and often used in
# conjunction with the epause function. If the EBEEP_IGNORE env var is set,
# don't beep at all. Defined in EAPIs 0 1 and 2.
ebeep() {
local n
if [[ -z ${EBEEP_IGNORE} ]] ; then
for ((n=1 ; n <= ${1:-5} ; n++)) ; do
echo -ne "\a"
sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
echo -ne "\a"
sleep 1
done
fi
}
;;
*)
ebeep() {
ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at https://bugs.gentoo.org"
}
epause() {
ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at https://bugs.gentoo.org"
}
;;
esac
case ${EAPI:-0} in
0|1|2|3|4)
# @FUNCTION: usex
# @USAGE: <USE flag> [true output] [false output] [true suffix] [false suffix]
# @DESCRIPTION:
# Proxy to declare usex for package managers or EAPIs that do not provide it
# and use the package manager implementation when available (i.e. EAPI >= 5).
# If USE flag is set, echo [true output][true suffix] (defaults to "yes"),
# otherwise echo [false output][false suffix] (defaults to "no").
usex() { use "$1" && echo "${2-yes}$4" || echo "${3-no}$5" ; } #382963
;;
esac
case ${EAPI:-0} in
0|1|2|3|4|5)
# @FUNCTION: einstalldocs
# @DESCRIPTION:
# Install documentation using DOCS and HTML_DOCS, in EAPIs that do not
# provide this function. When available (i.e., in EAPI 6 or later),
# the package manager implementation should be used instead.
#
# If DOCS is declared and non-empty, all files listed in it are
# installed. The files must exist, otherwise the function will fail.
# In EAPI 4 and 5, DOCS may specify directories as well; in earlier
# EAPIs using directories is unsupported.
#
# If DOCS is not declared, the files matching patterns given
# in the default EAPI implementation of src_install will be installed.
# If this is undesired, DOCS can be set to empty value to prevent any
# documentation from being installed.
#
# If HTML_DOCS is declared and non-empty, all files and/or directories
# listed in it are installed as HTML docs (using dohtml).
#
# Both DOCS and HTML_DOCS can either be an array or a whitespace-
# separated list. Whenever directories are allowed, '<directory>/.' may
# be specified in order to install all files within the directory
# without creating a sub-directory in docdir.
#
# Passing additional options to dodoc and dohtml is not supported.
# If you needed such a thing, you need to call those helpers explicitly.
einstalldocs() {
debug-print-function ${FUNCNAME} "${@}"
local dodoc_opts=-r
has ${EAPI} 0 1 2 3 && dodoc_opts=
if ! declare -p DOCS &>/dev/null ; then
local d
for d in README* ChangeLog AUTHORS NEWS TODO CHANGES \
THANKS BUGS FAQ CREDITS CHANGELOG ; do
if [[ -s ${d} ]] ; then
dodoc "${d}" || die
fi
done
elif [[ $(declare -p DOCS) == "declare -a"* ]] ; then
if [[ ${DOCS[@]} ]] ; then
dodoc ${dodoc_opts} "${DOCS[@]}" || die
fi
else
if [[ ${DOCS} ]] ; then
dodoc ${dodoc_opts} ${DOCS} || die
fi
fi
if [[ $(declare -p HTML_DOCS 2>/dev/null) == "declare -a"* ]] ; then
if [[ ${HTML_DOCS[@]} ]] ; then
dohtml -r "${HTML_DOCS[@]}" || die
fi
else
if [[ ${HTML_DOCS} ]] ; then
dohtml -r ${HTML_DOCS} || die
fi
fi
return 0
}
# @FUNCTION: in_iuse
# @USAGE: <flag>
# @DESCRIPTION:
# Determines whether the given flag is in IUSE. Strips IUSE default
# prefixes as necessary. In EAPIs where it is available (i.e., EAPI 6
# or later), the package manager implementation should be used instead.
#
# Note that this function must not be used in the global scope.
in_iuse() {
debug-print-function ${FUNCNAME} "${@}"
[[ ${#} -eq 1 ]] || die "Invalid args to ${FUNCNAME}()"
local flag=${1}
local liuse=( ${IUSE} )
has "${flag}" "${liuse[@]#[+-]}"
}
;;
esac
case ${EAPI:-0} in
0|1|2|3|4|5|6)
# @FUNCTION: eqawarn
# @USAGE: [message]
# @DESCRIPTION:
# Proxy to ewarn for package managers that don't provide eqawarn and use the PM
# implementation if available. Reuses PORTAGE_ELOG_CLASSES as set by the dev
# profile.
if ! declare -F eqawarn >/dev/null ; then
eqawarn() {
has qa ${PORTAGE_ELOG_CLASSES} && ewarn "$@"
:
}
fi
;;
esac
fi
| Gentoo Eclass | 5 | NighttimeDriver50000/Sabayon-Packages | local_overlay/eclass/eutils.eclass | [
"MIT"
] |
{% if doc.this %}
<h3>Method's `this`</h3>
{$ doc.this | marked $}
{% endif %}
| HTML | 2 | alexgberry/angular.js | docs/config/templates/ngdoc/lib/this.template.html | [
"MIT"
] |
temp0[-]
temp1[-]
temp2[-]
temp3[-]
temp4[-]
temp5[-]
randomh[temp0+randomh-]
randoml[temp1+randoml-]
temp3+++++++[temp2+++++++++++@temp3-]
temp2[
temp0[randomh+temp3+temp0-]
temp3[temp0+temp3-]
temp1[randomh+temp3+temp4+temp1-]
temp4[temp1+temp4-]
temp3[
randoml+[temp4+temp5+randoml-]
temp5[randoml+temp5-]+
temp4[temp5-temp4[-]]
temp5[randomh+temp5-]
temp3-]
temp2-]
++++++[temp3++++++++temp2-]
temp3-[
temp1[randomh+temp2+temp1-]
temp2[temp1+temp2-]
temp3-]
temp0[-]temp1[-]+++++[temp0+++++temp1-]
temp0[
randoml+[temp1+temp2+randoml-]
temp2[randoml+temp2-]+
temp1[temp2-temp1[-]]
temp2[randomh+temp2-]
temp0-]
++++++[randomh+++++++++temp0-]
randomh[x+temp0+randomh-]
temp0[randomh+temp0-]
| Brainfuck | 0 | iabhimanyu/Algorithms | Random Number/random.bf | [
"MIT"
] |
#ifndef __CVE_2016_0040_LIBRARY_H__
#define __CVE_2016_0040_LIBRARY_H__
#include <windef.h>
BOOLEAN TriggerExploit(VOID);
#endif //__CVE_2016_0040_LIBRARY_H__ | C | 1 | OsmanDere/metasploit-framework | external/source/exploits/CVE-2016-0040/Library/Library.h | [
"BSD-2-Clause",
"BSD-3-Clause"
] |
--TEST--
Coalesce assign (??=): Exception handling
--FILE--
<?php
$foo = "fo";
$foo .= "o";
$bar = "ba";
$bar .= "r";
function id($arg) {
echo "id($arg)\n";
return $arg;
}
function do_throw($msg) {
throw new Exception($msg);
}
$ary = [];
try {
$ary[id($foo)] ??= do_throw("ex1");
} catch (Exception $e) {
echo $e->getMessage(), "\n";
}
var_dump($ary);
class AA implements ArrayAccess {
public function offsetExists($k): bool {
return true;
}
public function &offsetGet($k): mixed {
$var = ["foo" => "bar"];
return $var;
}
public function offsetSet($k,$v): void {}
public function offsetUnset($k): void {}
}
class Dtor {
public function __destruct() {
throw new Exception("dtor");
}
}
$ary = new AA;
try {
$ary[new Dtor][id($foo)] ??= $bar;
} catch (Exception $e) {
echo $e->getMessage(), "\n";
}
var_dump($foo);
class AA2 implements ArrayAccess {
public function offsetExists($k): bool {
return false;
}
public function offsetGet($k): mixed {
return null;
}
public function offsetSet($k,$v): void {}
public function offsetUnset($k): void {}
}
$ary = ["foo" => new AA2];
try {
$ary[id($foo)][new Dtor] ??= $bar;
} catch (Exception $e) {
echo $e->getMessage(), "\n";
}
var_dump($foo);
?>
--EXPECT--
id(foo)
ex1
array(0) {
}
id(foo)
dtor
string(3) "foo"
id(foo)
dtor
string(3) "foo"
| PHP | 4 | NathanFreeman/php-src | Zend/tests/assign_coalesce_002.phpt | [
"PHP-3.01"
] |
package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.OgnlModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.view.ObjectView;
/**
* Term view of OgnlCommand
* @author gongdewei 2020/4/29
*/
public class OgnlView extends ResultView<OgnlModel> {
@Override
public void draw(CommandProcess process, OgnlModel model) {
if (model.getMatchedClassLoaders() != null) {
process.write("Matched classloaders: \n");
ClassLoaderView.drawClassLoaders(process, model.getMatchedClassLoaders(), false);
process.write("\n");
return;
}
int expand = model.getExpand();
Object value = model.getValue();
String resultStr = StringUtils.objectToString(expand >= 0 ? new ObjectView(value, expand).draw() : value);
process.write(resultStr).write("\n");
}
}
| Java | 4 | weihubeats/arthas | core/src/main/java/com/taobao/arthas/core/command/view/OgnlView.java | [
"Apache-2.0"
] |
= This is the document title
Author McAuthorson <[email protected]>
== Table of Content
:toc:
== Paragraphs
[.lead]
This text will be styled as a lead paragraph with a larger font.
This is a normal paragraph.
This is a literal paragraph that is offset by one space,
it will be rendered in a fixed-width font.
NOTE: This is an admonition paragraph
TIP: This is another admonition paragraph
== Formatted text
*bold text*
_italic text_
*_bold italic text_*
`monospace text`
`*bold monospace*`
`_italic monospace_`
`*_bold and italic monospace_*`
The following word is #highlighted#
The following words are [.small]#small print#
The following word is [.underline]#underlined#
The following word is [.line-through]#line-through#
The following word is [.big]#big#
The following word is printed in ^superscript^
The following word is printed in ~sub-script~
== Include
include::not_existing.adoc[]
== Breaks
Here we have a +
line break.
Below is a horizontal rule.
'''
And below here is a page break.
<<<
== Lists
* This is
* an unordered
* list
** with nested
*** elements
'''
- This is also an
- unordered
- list
'''
. And this is
. an ordered
. list
.. with nested
... elements
'''
//* [*] checked
* [x] also checked
* [ ] not checked
* normal list item
'''
[qanda]
What is this?::
This is a Q&A
And what is this?:: Also a Q&A
== Links
The following link will be created automatically: https://asciidoctor.org
.An image caption
image::not_existing.jpg[alt text]
.A video caption
video::not_existing.mp4[alt text]
== Source Code
The following word is `monospace`.
....
This is a literal block
where linebreaks are rendered
....
.example.java
[source,java]
----
public class Example { // <1>
private static boolean isExample = true; // <2>
}
----
<1> This is a callout
<2> This is another callout
== Misc
.A sidebar
****
This will be rendered like a sidebar
****
____
This is a random blockquote
____
[quote, Albert Einstein, 'Scientist']
____
This is not actually something Einstein said
____
// here we have a single line comment
////
and this is a
multiline comment
////
.A Table
[%header]
|===
|Header Column 1 |Header Column 2 |And the last header column
|Cell in col1
|Cell in col2
|Cell in col3
|Cell in col1, row2
|Cell in col2, row2
|Cell in col3, row2
|===
.A Table from CSV
[%header, format=csv]
|===
header col1, header col2, header col3
This,is the first, row
This, is the second, row
|===
| AsciiDoc | 4 | JesseVermeulen123/bat | tests/syntax-tests/source/AsciiDoc/test.adoc | [
"Apache-2.0",
"MIT"
] |
// run-rustfix
#![crate_type="lib"]
#![allow(unused)]
fn f<T: ?Sized>(t: T) {}
//~^ ERROR the size for values of type `T` cannot be known at compilation time
| Rust | 4 | mbc-git/rust | src/test/ui/unsized/unsized-fn-arg.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
// run-pass
#![feature(fn_traits)]
fn main() {
let mut zero = || 0;
let x = zero.call_mut(());
assert_eq!(x, 0);
}
| Rust | 4 | Eric-Arellano/rust | src/test/ui/unboxed-closures/unboxed-closures-infer-explicit-call-early.rs | [
"ECL-2.0",
"Apache-2.0",
"MIT-0",
"MIT"
] |
/*
* Copyright (C) 2015 Square, Inc.
*
* 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.
*/
package okhttp3;
import java.net.URI;
import java.net.URL;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import okhttp3.internal.Util;
import okio.Buffer;
import okio.ByteString;
import static org.junit.jupiter.api.Assertions.fail;
/** Tests how each code point is encoded and decoded in the context of each URL component. */
class UrlComponentEncodingTester {
private static final int UNICODE_2 = 0x07ff; // Arbitrary code point that's 2 bytes in UTF-8.
private static final int UNICODE_3 = 0xffff; // Arbitrary code point that's 3 bytes in UTF-8.
private static final int UNICODE_4 = 0x10ffff; // Arbitrary code point that's 4 bytes in UTF-8.
private final Map<Integer, Encoding> encodings = new LinkedHashMap<>();
private final StringBuilder uriEscapedCodePoints = new StringBuilder();
private final StringBuilder uriStrippedCodePoints = new StringBuilder();
private UrlComponentEncodingTester() {
}
/**
* Returns a new instance configured with a default encode set for the ASCII range. The specific
* rules vary per-component: for example, '?' may be identity-encoded in a fragment, but must be
* percent-encoded in a path.
*
* See https://url.spec.whatwg.org/#percent-encoded-bytes
*/
public static UrlComponentEncodingTester newInstance() {
return new UrlComponentEncodingTester()
.allAscii(Encoding.IDENTITY)
.nonPrintableAscii(Encoding.PERCENT)
.override(Encoding.SKIP, '\t', '\n', '\f', '\r')
.override(Encoding.PERCENT, ' ', '"', '#', '<', '>', '?', '`')
.override(Encoding.PERCENT, UNICODE_2, UNICODE_3, UNICODE_4);
}
private UrlComponentEncodingTester allAscii(Encoding encoding) {
for (int i = 0; i < 128; i++) {
encodings.put(i, encoding);
}
return this;
}
public UrlComponentEncodingTester override(Encoding encoding, int... codePoints) {
for (int codePoint : codePoints) {
encodings.put(codePoint, encoding);
}
return this;
}
public UrlComponentEncodingTester nonPrintableAscii(Encoding encoding) {
encodings.put( 0x0, encoding); // Null character
encodings.put( 0x1, encoding); // Start of Header
encodings.put( 0x2, encoding); // Start of Text
encodings.put( 0x3, encoding); // End of Text
encodings.put( 0x4, encoding); // End of Transmission
encodings.put( 0x5, encoding); // Enquiry
encodings.put( 0x6, encoding); // Acknowledgment
encodings.put( 0x7, encoding); // Bell
encodings.put((int) '\b', encoding); // Backspace
encodings.put( 0xb, encoding); // Vertical Tab
encodings.put( 0xe, encoding); // Shift Out
encodings.put( 0xf, encoding); // Shift In
encodings.put( 0x10, encoding); // Data Link Escape
encodings.put( 0x11, encoding); // Device Control 1 (oft. XON)
encodings.put( 0x12, encoding); // Device Control 2
encodings.put( 0x13, encoding); // Device Control 3 (oft. XOFF)
encodings.put( 0x14, encoding); // Device Control 4
encodings.put( 0x15, encoding); // Negative Acknowledgment
encodings.put( 0x16, encoding); // Synchronous idle
encodings.put( 0x17, encoding); // End of Transmission Block
encodings.put( 0x18, encoding); // Cancel
encodings.put( 0x19, encoding); // End of Medium
encodings.put( 0x1a, encoding); // Substitute
encodings.put( 0x1b, encoding); // Escape
encodings.put( 0x1c, encoding); // File Separator
encodings.put( 0x1d, encoding); // Group Separator
encodings.put( 0x1e, encoding); // Record Separator
encodings.put( 0x1f, encoding); // Unit Separator
encodings.put( 0x7f, encoding); // Delete
return this;
}
public UrlComponentEncodingTester nonAscii(Encoding encoding) {
encodings.put(UNICODE_2, encoding);
encodings.put(UNICODE_3, encoding);
encodings.put(UNICODE_4, encoding);
return this;
}
/**
* Configure code points to be escaped for conversion to {@code java.net.URI}. That class is more
* strict than the others.
*/
public UrlComponentEncodingTester escapeForUri(int... codePoints) {
uriEscapedCodePoints.append(new String(codePoints, 0, codePoints.length));
return this;
}
/**
* Configure code points to be stripped in conversion to {@code java.net.URI}. That class is more
* strict than the others.
*/
public UrlComponentEncodingTester stripForUri(int... codePoints) {
uriStrippedCodePoints.append(new String(codePoints, 0, codePoints.length));
return this;
}
public UrlComponentEncodingTester test(Component component) {
for (Map.Entry<Integer, Encoding> entry : encodings.entrySet()) {
Encoding encoding = entry.getValue();
int codePoint = entry.getKey();
String codePointString = Encoding.IDENTITY.encode(codePoint);
if (encoding == Encoding.FORBIDDEN) {
testForbidden(codePoint, codePointString, component);
continue;
}
testEncodeAndDecode(codePoint, codePointString, component);
if (encoding == Encoding.SKIP) continue;
testParseOriginal(codePoint, codePointString, encoding, component);
testParseAlreadyEncoded(codePoint, encoding, component);
testToUrl(codePoint, encoding, component);
testFromUrl(codePoint, encoding, component);
testUri(codePoint, codePointString, encoding, component);
}
return this;
}
private void testParseAlreadyEncoded(int codePoint, Encoding encoding, Component component) {
String expected = component.canonicalize(encoding.encode(codePoint));
String urlString = component.urlString(expected);
HttpUrl url = HttpUrl.get(urlString);
String actual = component.encodedValue(url);
if (!actual.equals(expected)) {
fail(Util.format("Encoding %s %#x using %s: '%s' != '%s'",
component, codePoint, encoding, actual, expected));
}
}
private void testEncodeAndDecode(int codePoint, String codePointString, Component component) {
HttpUrl.Builder builder = HttpUrl.get("http://host/").newBuilder();
component.set(builder, codePointString);
HttpUrl url = builder.build();
String expected = component.canonicalize(codePointString);
String actual = component.get(url);
if (!expected.equals(actual)) {
fail(Util.format("Roundtrip %s %#x %s", component, codePoint, url));
}
}
private void testParseOriginal(
int codePoint, String codePointString, Encoding encoding, Component component) {
String expected = encoding.encode(codePoint);
if (encoding != Encoding.PERCENT) return;
String urlString = component.urlString(codePointString);
HttpUrl url = HttpUrl.get(urlString);
String actual = component.encodedValue(url);
if (!actual.equals(expected)) {
fail(Util.format("Encoding %s %#02x using %s: '%s' != '%s'",
component, codePoint, encoding, actual, expected));
}
}
private void testToUrl(int codePoint, Encoding encoding, Component component) {
String encoded = encoding.encode(codePoint);
HttpUrl httpUrl = HttpUrl.get(component.urlString(encoded));
URL javaNetUrl = httpUrl.url();
if (!javaNetUrl.toString().equals(javaNetUrl.toString())) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
}
private void testFromUrl(int codePoint, Encoding encoding, Component component) {
String encoded = encoding.encode(codePoint);
HttpUrl httpUrl = HttpUrl.get(component.urlString(encoded));
HttpUrl toAndFromJavaNetUrl = HttpUrl.get(httpUrl.url());
if (!toAndFromJavaNetUrl.equals(httpUrl)) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
}
private void testUri(
int codePoint, String codePointString, Encoding encoding, Component component) {
if (codePoint == '%') return;
String encoded = encoding.encode(codePoint);
HttpUrl httpUrl = HttpUrl.get(component.urlString(encoded));
URI uri = httpUrl.uri();
HttpUrl toAndFromUri = HttpUrl.get(uri);
boolean uriStripped = uriStrippedCodePoints.indexOf(codePointString) != -1;
if (uriStripped) {
if (!uri.toString().equals(component.urlString(""))) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
return;
}
// If the URI has more escaping than the HttpURL, check that the decoded values still match.
boolean uriEscaped = uriEscapedCodePoints.indexOf(codePointString) != -1;
if (uriEscaped) {
if (uri.toString().equals(httpUrl.toString())) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
if (!component.get(toAndFromUri).equals(codePointString)) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
return;
}
// Check that the URI and HttpURL have the exact same escaping.
if (!toAndFromUri.equals(httpUrl)) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
if (!uri.toString().equals(httpUrl.toString())) {
fail(Util.format("Encoding %s %#x using %s", component, codePoint, encoding));
}
}
private void testForbidden(int codePoint, String codePointString, Component component) {
HttpUrl.Builder builder = HttpUrl.get("http://host/").newBuilder();
try {
component.set(builder, codePointString);
fail(Util.format("Accepted forbidden code point %s %#x", component, codePoint));
} catch (IllegalArgumentException expected) {
}
}
public enum Encoding {
IDENTITY {
@Override public String encode(int codePoint) {
return new String(new int[] {codePoint}, 0, 1);
}
},
PERCENT {
@Override public String encode(int codePoint) {
ByteString utf8 = ByteString.encodeUtf8(IDENTITY.encode(codePoint));
Buffer percentEncoded = new Buffer();
for (int i = 0; i < utf8.size(); i++) {
percentEncoded.writeUtf8(Util.format("%%%02X", utf8.getByte(i) & 0xff));
}
return percentEncoded.readUtf8();
}
},
/** URLs that contain this character in this component are invalid. */
FORBIDDEN,
/** This code point is special and should not be tested. */
SKIP;
public String encode(int codePoint) {
throw new UnsupportedOperationException();
}
}
public enum Component {
USER {
@Override public String urlString(String value) {
return "http://" + value + "@example.com/";
}
@Override public String encodedValue(HttpUrl url) {
return url.encodedUsername();
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.username(value);
}
@Override public String get(HttpUrl url) {
return url.username();
}
},
PASSWORD {
@Override public String urlString(String value) {
return "http://:" + value + "@example.com/";
}
@Override public String encodedValue(HttpUrl url) {
return url.encodedPassword();
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.password(value);
}
@Override public String get(HttpUrl url) {
return url.password();
}
},
HOST {
@Override public String urlString(String value) {
return "http://a" + value + "z.com/";
}
@Override public String encodedValue(HttpUrl url) {
return get(url);
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.host("a" + value + "z.com");
}
@Override public String get(HttpUrl url) {
String host = url.host();
return host.substring(1, host.length() - 5).toLowerCase(Locale.ROOT);
}
@Override public String canonicalize(String s) {
return s.toLowerCase(Locale.US);
}
},
PATH {
@Override public String urlString(String value) {
return "http://example.com/a" + value + "z/";
}
@Override public String encodedValue(HttpUrl url) {
String path = url.encodedPath();
return path.substring(2, path.length() - 2);
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.addPathSegment("a" + value + "z");
}
@Override public String get(HttpUrl url) {
String pathSegment = url.pathSegments().get(0);
return pathSegment.substring(1, pathSegment.length() - 1);
}
},
QUERY {
@Override public String urlString(String value) {
return "http://example.com/?a" + value + "z";
}
@Override public String encodedValue(HttpUrl url) {
String query = url.encodedQuery();
return query.substring(1, query.length() - 1);
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.query("a" + value + "z");
}
@Override public String get(HttpUrl url) {
String query = url.query();
return query.substring(1, query.length() - 1);
}
},
QUERY_VALUE {
@Override public String urlString(String value) {
return "http://example.com/?q=a" + value + "z";
}
@Override public String encodedValue(HttpUrl url) {
String query = url.encodedQuery();
return query.substring(3, query.length() - 1);
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.addQueryParameter("q", "a" + value + "z");
}
@Override public String get(HttpUrl url) {
String value = url.queryParameter("q");
return value.substring(1, value.length() - 1);
}
},
FRAGMENT {
@Override public String urlString(String value) {
return "http://example.com/#a" + value + "z";
}
@Override public String encodedValue(HttpUrl url) {
String fragment = url.encodedFragment();
return fragment.substring(1, fragment.length() - 1);
}
@Override public void set(HttpUrl.Builder builder, String value) {
builder.fragment("a" + value + "z");
}
@Override public String get(HttpUrl url) {
String fragment = url.fragment();
return fragment.substring(1, fragment.length() - 1);
}
};
public abstract String urlString(String value);
public abstract String encodedValue(HttpUrl url);
public abstract void set(HttpUrl.Builder builder, String value);
public abstract String get(HttpUrl url);
/**
* Returns a character equivalent to 's' in this component. This is used to convert hostname
* characters to lowercase.
*/
public String canonicalize(String s) {
return s;
}
}
}
| Java | 5 | nowkarol/okhttp | okhttp/src/test/java/okhttp3/UrlComponentEncodingTester.java | [
"Apache-2.0"
] |
Red/System [
Title: "Red/System execeptions test script"
Author: "Nenad Rakocevic"
File: %exceptions-test.reds
Tabs: 4
Rights: "Copyright (C) 2011-2015 Red Foundation. All rights reserved."
License: "BSD-3 - https://github.com/red/red/blob/origin/BSD-3-License.txt"
]
#include %../../../../quick-test/quick-test.reds
~~~start-file~~~ "break/continue"
--test-- "break-1"
until [break true]
--assert true
--test-- "break-2"
i: 5
until [
break
i: i - 1
i = 0
]
--assert i = 5
--test-- "break-3"
i: 5
until [
i: i - 1
break
i = 0
]
--assert i = 4
--test-- "break-4"
i: 5
until [
if i = 3 [break]
i: i - 1
i = 0
]
--assert i = 3
--test-- "continue"
i: 5
until [
i: i - 1
if i > 2 [continue]
if i > 2 [--assert false] ;-- make it fail here
i = 0
]
--assert i = 0
--test-- "nested-1"
levelA: 0
levelB: 0
i: 3
j: 5
until [
levelA: levelA + 1
i: i - 1
j: 5
until [
levelB: levelB + 1
j: j - 1
either j = 4 [continue][break]
j = 0
]
either i = 2 [continue][break]
i = 0
]
--assert levelA = 2
--assert levelB = 4
--test-- "nested-2"
levelA: 0
levelB: 0
i: 3
j: 5
while [i > 0][
levelA: levelA + 1
i: i - 1
j: 5
until [
levelB: levelB + 1
j: j - 1
either j = 4 [continue][break]
j = 0
]
either i = 2 [continue][break]
]
--assert levelA = 2
--assert levelB = 4
--test-- "nested-3"
levelA: 0
levelB: 0
i: 3
j: 5
while [i > 0][
levelA: levelA + 1
i: i - 1
j: 5
while [j > 0][
levelB: levelB + 1
j: j - 1
either j = 4 [continue][break]
]
either i = 2 [continue][break]
]
--assert levelA = 2
--assert levelB = 4
~~~end-file~~~
| Red | 4 | 0xflotus/red | system/tests/source/units/exceptions-test.reds | [
"BSL-1.0",
"BSD-3-Clause"
] |
// Copyright 2010-2014 RethinkDB, all rights reserved.
#include "rdb_protocol/geo/ellipsoid.hpp"
#include "rpc/serialize_macros.hpp"
RDB_IMPL_SERIALIZABLE_2(ellipsoid_spec_t, equator_radius_, flattening_);
INSTANTIATE_SERIALIZABLE_FOR_CLUSTER(ellipsoid_spec_t);
| C++ | 3 | zadcha/rethinkdb | src/rdb_protocol/geo/ellipsoid.cc | [
"Apache-2.0"
] |
import fs from "fs-extra"
import path from "path"
import mkdirp from "mkdirp"
import * as Joi from "@hapi/joi"
import isUrl from "is-url"
import fetch from "node-fetch"
import isBinaryPath from "is-binary-path"
import getDiff from "../utils/get-diff"
import resourceSchema from "../resource-schema"
const makePath = (root, relativePath) => path.join(root, relativePath)
const fileExists = fullPath => {
try {
fs.accessSync(fullPath, fs.constants.F_OK)
return true
} catch (e) {
return false
}
}
const downloadFile = async (url, filePath) =>
fetch(url).then(
res =>
new Promise((resolve, reject) => {
const dest = fs.createWriteStream(filePath)
res.body.pipe(dest)
dest.on(`finish`, () => {
resolve(true)
})
dest.on(`error`, reject)
})
)
const create = async ({ root }, { id, path: filePath, content }) => {
const fullPath = makePath(root, filePath)
const { dir } = path.parse(fullPath)
await mkdirp(dir)
if (isUrl(content)) {
await downloadFile(content, fullPath)
} else {
await fs.ensureFile(fullPath)
await fs.writeFile(fullPath, content)
}
return await read({ root }, filePath)
}
const update = async (context, resource) => {
const fullPath = makePath(context.root, resource.id)
await fs.writeFile(fullPath, resource.content)
return await read(context, resource.id)
}
const read = async (context, id) => {
const fullPath = makePath(context.root, id)
let content = ``
if (fileExists(fullPath)) {
content = await fs.readFile(fullPath, `utf8`)
} else {
return undefined
}
const resource = { id, path: id, content }
resource._message = message(resource)
return resource
}
const destroy = async (context, fileResource) => {
const fullPath = makePath(context.root, fileResource.id)
await fs.unlink(fullPath)
return fileResource
}
// TODO pass action to plan
export const plan = async (context, { id, path: filePath, content }) => {
let currentResource
if (!isBinaryPath(filePath)) {
currentResource = await read(context, filePath)
} else {
currentResource = `Binary file`
}
let newState = content
if (isUrl(content)) {
if (!isBinaryPath(filePath)) {
const res = await fetch(content)
newState = await res.text()
} else {
newState = `Binary file`
}
}
const plan = {
currentState: (currentResource && currentResource.content) || ``,
newState,
describe: `Write ${filePath}`,
diff: ``,
}
if (plan.currentState !== plan.newState) {
plan.diff = getDiff(plan.currentState, plan.newState)
}
return plan
}
const message = resource => `Wrote file ${resource.path}`
const schema = {
path: Joi.string(),
content: Joi.string(),
...resourceSchema,
}
export const validate = resource =>
Joi.validate(resource, schema, { abortEarly: false })
export { schema, fileExists as exists, create, update, read, destroy }
| JavaScript | 5 | pipaliyajaydip/gatsby | packages/gatsby-recipes/src/providers/fs/file.js | [
"MIT"
] |
<?php
# Check for newer version
if(Library_Data_Version::check())
{ ?>
<div class="header corner full-size padding" style="float:left; text-align:center; margin-top:10px;">
A newer version of phpMemcachedAdmin may be available, visit <a href="https://blog.elijaa.org/phpmemcachedadmin-download/" target="_blank">PHPMemcachedAdmin Blog</a> to know more.
<?php
} else { ?>
<div class="sub-header corner full-size padding" style="float:left; text-align:center; margin-top:10px;">
<a href="https://github.com/elijaa/phpmemcachedadmin" target="_blank">PHPMemcachedAdmin on GitHub</a> -
<a href="https://blog.elijaa.org" target="_blank">PHPMemcachedAdmin Blog</a> -
<a href="http://memcached.org" target="_blank">Memcached.org</a>
<?php
} ?>
</div>
</div>
</body>
</html> | HTML+PHP | 3 | axelVO/tourComperator | .devilbox/www/htdocs/vendor/phpmemcachedadmin-1.3.0/View/Footer.phtml | [
"MIT"
] |
'reach 0.1';
// Stage 1 JS feature, pipe LHS into RHS function.
// Docs:
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Pipeline_operator
export const main =
Reach.App(
{},
[Participant('A', {})],
(A) => {
const double = x => x * 2;
5 |> double |> Array.iota;
});
| RenderScript | 3 | chikeabuah/reach-lang | hs/t/n/pipeline_operator.rsh | [
"Apache-2.0"
] |
// @target:es6
let
x | TypeScript | 0 | nilamjadhav/TypeScript | tests/cases/conformance/es6/variableDeclarations/VariableDeclaration12_es6.ts | [
"Apache-2.0"
] |
"""Describe group states."""
from homeassistant.components.group import GroupIntegrationRegistry
from homeassistant.const import STATE_CLOSED, STATE_OPEN
from homeassistant.core import HomeAssistant, callback
@callback
def async_describe_on_off_states(
hass: HomeAssistant, registry: GroupIntegrationRegistry
) -> None:
"""Describe group on off states."""
# On means open, Off means closed
registry.on_off_states({STATE_OPEN}, STATE_CLOSED)
| Python | 4 | MrDelik/core | homeassistant/components/cover/group.py | [
"Apache-2.0"
] |
FROM node:lts
# Create app directory
WORKDIR /rxjs
COPY . .
WORKDIR /rxjs/docs_app
RUN npm run setup
EXPOSE 4200
CMD ["npm", "start:docker"] | Dockerfile | 3 | KevLeong/rxjs | Dockerfile | [
"Apache-2.0"
] |
<%@ page contentType="text/html; charset=utf-8" %>
<jsp:useBean id="model" type="com.dianping.cat.report.page.alert.Model" scope="request"/>
${model.alertResult}
| Java Server Pages | 2 | woozhijun/cat | cat-home/src/main/webapp/jsp/report/alert/alertResult.jsp | [
"Apache-2.0"
] |
// Ported from musl, which is licensed under the MIT license:
// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT
//
// https://git.musl-libc.org/cgit/musl/tree/src/math/__cos.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/__cosdf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/__sin.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/__sindf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/__tand.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/__tandf.c
// kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
// Input x is assumed to be bounded by ~pi/4 in magnitude.
// Input y is the tail of x.
//
// Algorithm
// 1. Since cos(-x) = cos(x), we need only to consider positive x.
// 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0.
// 3. cos(x) is approximated by a polynomial of degree 14 on
// [0,pi/4]
// 4 14
// cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x
// where the remez error is
//
// | 2 4 6 8 10 12 14 | -58
// |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2
// | |
//
// 4 6 8 10 12 14
// 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then
// cos(x) ~ 1 - x*x/2 + r
// since cos(x+y) ~ cos(x) - sin(x)*y
// ~ cos(x) - x*y,
// a correction term is necessary in cos(x) and hence
// cos(x+y) = 1 - (x*x/2 - (r - x*y))
// For better accuracy, rearrange to
// cos(x+y) ~ w + (tmp + (r-x*y))
// where w = 1 - x*x/2 and tmp is a tiny correction term
// (1 - x*x/2 == w + tmp exactly in infinite precision).
// The exactness of w + tmp in infinite precision depends on w
// and tmp having the same precision as x. If they have extra
// precision due to compiler bugs, then the extra precision is
// only good provided it is retained in all terms of the final
// expression for cos(). Retention happens in all cases tested
// under FreeBSD, so don't pessimize things by forcibly clipping
// any extra precision in w.
pub fn __cos(x: f64, y: f64) f64 {
const C1 = 4.16666666666666019037e-02; // 0x3FA55555, 0x5555554C
const C2 = -1.38888888888741095749e-03; // 0xBF56C16C, 0x16C15177
const C3 = 2.48015872894767294178e-05; // 0x3EFA01A0, 0x19CB1590
const C4 = -2.75573143513906633035e-07; // 0xBE927E4F, 0x809C52AD
const C5 = 2.08757232129817482790e-09; // 0x3E21EE9E, 0xBDB4B1C4
const C6 = -1.13596475577881948265e-11; // 0xBDA8FAE9, 0xBE8838D4
const z = x * x;
const zs = z * z;
const r = z * (C1 + z * (C2 + z * C3)) + zs * zs * (C4 + z * (C5 + z * C6));
const hz = 0.5 * z;
const w = 1.0 - hz;
return w + (((1.0 - w) - hz) + (z * r - x * y));
}
pub fn __cosdf(x: f64) f32 {
// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).
const C0 = -0x1ffffffd0c5e81.0p-54; // -0.499999997251031003120
const C1 = 0x155553e1053a42.0p-57; // 0.0416666233237390631894
const C2 = -0x16c087e80f1e27.0p-62; // -0.00138867637746099294692
const C3 = 0x199342e0ee5069.0p-68; // 0.0000243904487962774090654
// Try to optimize for parallel evaluation as in __tandf.c.
const z = x * x;
const w = z * z;
const r = C2 + z * C3;
return @floatCast(f32, ((1.0 + z * C0) + w * C1) + (w * z) * r);
}
// kernel sin function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854
// Input x is assumed to be bounded by ~pi/4 in magnitude.
// Input y is the tail of x.
// Input iy indicates whether y is 0. (if iy=0, y assume to be 0).
//
// Algorithm
// 1. Since sin(-x) = -sin(x), we need only to consider positive x.
// 2. Callers must return sin(-0) = -0 without calling here since our
// odd polynomial is not evaluated in a way that preserves -0.
// Callers may do the optimization sin(x) ~ x for tiny x.
// 3. sin(x) is approximated by a polynomial of degree 13 on
// [0,pi/4]
// 3 13
// sin(x) ~ x + S1*x + ... + S6*x
// where
//
// |sin(x) 2 4 6 8 10 12 | -58
// |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2
// | x |
//
// 4. sin(x+y) = sin(x) + sin'(x')*y
// ~ sin(x) + (1-x*x/2)*y
// For better accuracy, let
// 3 2 2 2 2
// r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6))))
// then 3 2
// sin(x) = x + (S1*x + (x *(r-y/2)+y))
pub fn __sin(x: f64, y: f64, iy: i32) f64 {
const S1 = -1.66666666666666324348e-01; // 0xBFC55555, 0x55555549
const S2 = 8.33333333332248946124e-03; // 0x3F811111, 0x1110F8A6
const S3 = -1.98412698298579493134e-04; // 0xBF2A01A0, 0x19C161D5
const S4 = 2.75573137070700676789e-06; // 0x3EC71DE3, 0x57B1FE7D
const S5 = -2.50507602534068634195e-08; // 0xBE5AE5E6, 0x8A2B9CEB
const S6 = 1.58969099521155010221e-10; // 0x3DE5D93A, 0x5ACFD57C
const z = x * x;
const w = z * z;
const r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);
const v = z * x;
if (iy == 0) {
return x + v * (S1 + z * r);
} else {
return x - ((z * (0.5 * y - v * r) - y) - v * S1);
}
}
pub fn __sindf(x: f64) f32 {
// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).
const S1 = -0x15555554cbac77.0p-55; // -0.166666666416265235595
const S2 = 0x111110896efbb2.0p-59; // 0.0083333293858894631756
const S3 = -0x1a00f9e2cae774.0p-65; // -0.000198393348360966317347
const S4 = 0x16cd878c3b46a7.0p-71; // 0.0000027183114939898219064
// Try to optimize for parallel evaluation as in __tandf.c.
const z = x * x;
const w = z * z;
const r = S3 + z * S4;
const s = z * x;
return @floatCast(f32, (x + s * (S1 + z * S2)) + s * w * r);
}
// kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854
// Input x is assumed to be bounded by ~pi/4 in magnitude.
// Input y is the tail of x.
// Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is returned.
//
// Algorithm
// 1. Since tan(-x) = -tan(x), we need only to consider positive x.
// 2. Callers must return tan(-0) = -0 without calling here since our
// odd polynomial is not evaluated in a way that preserves -0.
// Callers may do the optimization tan(x) ~ x for tiny x.
// 3. tan(x) is approximated by a odd polynomial of degree 27 on
// [0,0.67434]
// 3 27
// tan(x) ~ x + T1*x + ... + T13*x
// where
//
// |tan(x) 2 4 26 | -59.2
// |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2
// | x |
//
// Note: tan(x+y) = tan(x) + tan'(x)*y
// ~ tan(x) + (1+x*x)*y
// Therefore, for better accuracy in computing tan(x+y), let
// 3 2 2 2 2
// r = x *(T2+x *(T3+x *(...+x *(T12+x *T13))))
// then
// 3 2
// tan(x+y) = x + (T1*x + (x *(r+y)+y))
//
// 4. For x in [0.67434,pi/4], let y = pi/4 - x, then
// tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y))
// = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y)))
pub fn __tan(x_: f64, y_: f64, odd: bool) f64 {
var x = x_;
var y = y_;
const T = [_]f64{
3.33333333333334091986e-01, // 3FD55555, 55555563
1.33333333333201242699e-01, // 3FC11111, 1110FE7A
5.39682539762260521377e-02, // 3FABA1BA, 1BB341FE
2.18694882948595424599e-02, // 3F9664F4, 8406D637
8.86323982359930005737e-03, // 3F8226E3, E96E8493
3.59207910759131235356e-03, // 3F6D6D22, C9560328
1.45620945432529025516e-03, // 3F57DBC8, FEE08315
5.88041240820264096874e-04, // 3F4344D8, F2F26501
2.46463134818469906812e-04, // 3F3026F7, 1A8D1068
7.81794442939557092300e-05, // 3F147E88, A03792A6
7.14072491382608190305e-05, // 3F12B80F, 32F0A7E9
-1.85586374855275456654e-05, // BEF375CB, DB605373
2.59073051863633712884e-05, // 3EFB2A70, 74BF7AD4
};
const pio4 = 7.85398163397448278999e-01; // 3FE921FB, 54442D18
const pio4lo = 3.06161699786838301793e-17; // 3C81A626, 33145C07
var z: f64 = undefined;
var r: f64 = undefined;
var v: f64 = undefined;
var w: f64 = undefined;
var s: f64 = undefined;
var a: f64 = undefined;
var w0: f64 = undefined;
var a0: f64 = undefined;
var hx: u32 = undefined;
var sign: bool = undefined;
hx = @intCast(u32, @bitCast(u64, x) >> 32);
const big = (hx & 0x7fffffff) >= 0x3FE59428; // |x| >= 0.6744
if (big) {
sign = hx >> 31 != 0;
if (sign) {
x = -x;
y = -y;
}
x = (pio4 - x) + (pio4lo - y);
y = 0.0;
}
z = x * x;
w = z * z;
// Break x^5*(T[1]+x^2*T[2]+...) into
// x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
// x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));
v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));
s = z * x;
r = y + z * (s * (r + v) + y) + s * T[0];
w = x + r;
if (big) {
s = 1 - 2 * @intToFloat(f64, @boolToInt(odd));
v = s - 2.0 * (x + (r - w * w / (w + s)));
return if (sign) -v else v;
}
if (!odd) {
return w;
}
// -1.0/(x+r) has up to 2ulp error, so compute it accurately
w0 = w;
w0 = @bitCast(f64, @bitCast(u64, w0) & 0xffffffff00000000);
v = r - (w0 - x); // w0+v = r+x
a = -1.0 / w;
a0 = a;
a0 = @bitCast(f64, @bitCast(u64, a0) & 0xffffffff00000000);
return a0 + a * (1.0 + a0 * w0 + a0 * v);
}
pub fn __tandf(x: f64, odd: bool) f32 {
// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).
const T = [_]f64{
0x15554d3418c99f.0p-54, // 0.333331395030791399758
0x1112fd38999f72.0p-55, // 0.133392002712976742718
0x1b54c91d865afe.0p-57, // 0.0533812378445670393523
0x191df3908c33ce.0p-58, // 0.0245283181166547278873
0x185dadfcecf44e.0p-61, // 0.00297435743359967304927
0x1362b9bf971bcd.0p-59, // 0.00946564784943673166728
};
const z = x * x;
// Split up the polynomial into small independent terms to give
// opportunities for parallel evaluation. The chosen splitting is
// micro-optimized for Athlons (XP, X64). It costs 2 multiplications
// relative to Horner's method on sequential machines.
//
// We add the small terms from lowest degree up for efficiency on
// non-sequential machines (the lowest degree terms tend to be ready
// earlier). Apart from this, we don't care about order of
// operations, and don't need to to care since we have precision to
// spare. However, the chosen splitting is good for accuracy too,
// and would give results as accurate as Horner's method if the
// small terms were added from highest degree down.
const r = T[4] + z * T[5];
const t = T[2] + z * T[3];
const w = z * z;
const s = z * x;
const u = T[0] + z * T[1];
const r0 = (x + s * u) + (s * w) * (t + w * r);
return @floatCast(f32, if (odd) -1.0 / r0 else r0);
}
| Zig | 5 | lukekras/zig | lib/std/math/__trig.zig | [
"MIT"
] |
*** SoilNit parameters for: IOWA_01O1P1S1***
ROW SPACING (m)
1.24
Potential rate constants: Ratios and fractions:
m kh kL km kn kd fe fh r0 rL rm fa nq cs
1 0.00007 0.035 0.07 0.2 0.0000001 0.6 0.2 10 50 10 0.1 8 1e-05
2 0.00007 0.035 0.07 0.2 0.0000001 0.6 0.2 10 50 10 0.1 8 1e-05
3 0.00007 0.035 0.07 0.2 0.0000001 0.6 0.2 10 50 10 0.1 8 1e-05
4 0.00007 0.035 0.07 0.2 0.0000001 0.6 0.2 10 50 10 0.1 8 1e-05
| Nit | 1 | ARS-CSGCL-DT/MAIZSIM | SolarCorr/IOWA_01O1P1S1/IOWA.nit | [
"Unlicense"
] |
/*
* @LANG: c
*/
#include <stdio.h>
#include <string.h>
struct forder
{
int cs;
};
%%{
machine forder;
variable cs fsm->cs;
second = 'b'
>{printf("enter b1\n");}
>{printf("enter b2\n");}
;
first = 'a'
%{printf("leave a\n");}
@{printf("finish a\n");}
;
main := first . second . '\n';
}%%
%% write data;
void forder_init( struct forder *fsm )
{
%% write init;
}
void forder_execute( struct forder *fsm, const char *_data, int _len )
{
const char *p = _data;
const char *pe = _data+_len;
%% write exec;
}
int forder_finish( struct forder *fsm )
{
if ( fsm->cs == forder_error )
return -1;
if ( fsm->cs >= forder_first_final )
return 1;
return 0;
}
struct forder fsm;
void test( char *buf )
{
int len = strlen(buf);
forder_init( &fsm );
forder_execute( &fsm, buf, len );
if ( forder_finish( &fsm ) > 0 )
printf("ACCEPT\n");
else
printf("FAIL\n");
}
int main()
{
test( "ab\n");
test( "abx\n");
test( "" );
test(
"ab\n"
"fail after newline\n"
);
return 0;
}
##### OUTPUT #####
finish a
leave a
enter b1
enter b2
ACCEPT
finish a
leave a
enter b1
enter b2
FAIL
FAIL
finish a
leave a
enter b1
enter b2
FAIL
| Ragel in Ruby Host | 4 | podsvirov/colm-suite | test/ragel.d/forder1.rl | [
"MIT"
] |
= Documentation for Password Expiration Feature
The password expiration feature requires that users change their
password on login if it has expired (default: every 90 days). You can
force password expiration checks for all logged in users by adding
the following code to your route block:
rodauth.require_current_password
Additionally, you can set a minimum amount of time after a password
is changed until it can be changed again. By default this is not
enabled, but it can be enabled by setting +allow_password_change_after+
to a positive number of seconds.
It is not recommended to use this feature unless you have a policy that
requires it, as password expiration in general results in users chosing
weaker passwords. When asked to change their password, many users choose
a password that is based on their previous password, so forcing password
expiration is in general a net loss from a security perspective.
== Auth Value Methods
allow_password_change_after :: How long in seconds after the last password change until another password change is allowed (always allowed by default).
password_change_needed_redirect :: Where to redirect if a password needs to be changed.
password_changed_at_session_key :: The key in the session storing the timestamp the password was changed at.
password_expiration_changed_at_column :: The column in the +password_expiration_table+ containing the timestamp
password_expiration_default :: If the last password change time for an account cannot be determined, whether to consider the account expired, false by default.
password_expiration_error_flash :: The flash error to display when the account's password has expired and needs to be changed.
password_expiration_id_column :: The column in the +password_expiration_table+ containing the account's id.
password_expiration_table :: The table holding the password last changed timestamps.
password_not_changeable_yet_error_flash :: The flash error to display when not enough time has elapsed since the last password change and an attempt is made to change the password.
password_not_changeable_yet_redirect :: Where to redirect if the password cannot be changed yet.
require_password_change_after :: How long in seconds until a password change is required (90 days by default).
== Auth Methods
password_expired? :: Whether the password has expired for the related account.
update_password_changed_at :: Update the password last changed timestamp for the current account.
| RDoc | 4 | monorkin/rodauth | doc/password_expiration.rdoc | [
"MIT"
] |
/* A Bison parser, made by GNU Bison 2.7.91-dirty. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
variables, as they might otherwise be expanded by user macros.
There are some unavoidable exceptions within include files to
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "2.7.91-dirty"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 0
/* Push parsers. */
#define YYPUSH 0
/* Pull parsers. */
#define YYPULL 1
/* Copy the first part of user declarations. */
#line 1 "expression.y" /* yacc.c:356 */
import "ecdefs"
#define YYSIZE_T size_t
#define YYLTYPE Location
#include "grammar.h"
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
(Current).start = (Rhs)[1].start; \
(Current).end = (Rhs)[N].end;
#endif
Expression parsedExpression;
#define yyparse expression_yyparse
#define yylval expression_yylval
#define yychar expression_yychar
#define yydebug expression_yydebug
#define yynerrs expression_yynerrs
#define yylloc expression_yylloc
// #define PRECOMPILER
extern File fileInput;
extern char * yytext;
int yylex();
int yyerror();
#define uint _uint
default:
#line 102 "expression.ec" /* yacc.c:356 */
# ifndef YY_NULL
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULL nullptr
# else
# define YY_NULL 0
# endif
# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 1
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Token type. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
IDENTIFIER = 258,
CONSTANT = 259,
STRING_LITERAL = 260,
SIZEOF = 261,
PTR_OP = 262,
INC_OP = 263,
DEC_OP = 264,
LEFT_OP = 265,
RIGHT_OP = 266,
LE_OP = 267,
GE_OP = 268,
EQ_OP = 269,
NE_OP = 270,
AND_OP = 271,
OR_OP = 272,
MUL_ASSIGN = 273,
DIV_ASSIGN = 274,
MOD_ASSIGN = 275,
ADD_ASSIGN = 276,
SUB_ASSIGN = 277,
LEFT_ASSIGN = 278,
RIGHT_ASSIGN = 279,
AND_ASSIGN = 280,
XOR_ASSIGN = 281,
OR_ASSIGN = 282,
TYPE_NAME = 283,
TYPEDEF = 284,
EXTERN = 285,
STATIC = 286,
AUTO = 287,
REGISTER = 288,
CHAR = 289,
SHORT = 290,
INT = 291,
UINT = 292,
INT64 = 293,
INT128 = 294,
FLOAT128 = 295,
LONG = 296,
SIGNED = 297,
UNSIGNED = 298,
FLOAT = 299,
DOUBLE = 300,
CONST = 301,
VOLATILE = 302,
VOID = 303,
VALIST = 304,
STRUCT = 305,
UNION = 306,
ENUM = 307,
ELLIPSIS = 308,
CASE = 309,
DEFAULT = 310,
IF = 311,
SWITCH = 312,
WHILE = 313,
DO = 314,
FOR = 315,
GOTO = 316,
CONTINUE = 317,
BREAK = 318,
RETURN = 319,
IFX = 320,
ELSE = 321,
CLASS = 322,
THISCLASS = 323,
PROPERTY = 324,
SETPROP = 325,
GETPROP = 326,
NEWOP = 327,
RENEW = 328,
DELETE = 329,
EXT_DECL = 330,
EXT_STORAGE = 331,
IMPORT = 332,
DEFINE = 333,
VIRTUAL = 334,
ATTRIB = 335,
PUBLIC = 336,
PRIVATE = 337,
TYPED_OBJECT = 338,
ANY_OBJECT = 339,
_INCREF = 340,
EXTENSION = 341,
ASM = 342,
TYPEOF = 343,
WATCH = 344,
STOPWATCHING = 345,
FIREWATCHERS = 346,
WATCHABLE = 347,
CLASS_DESIGNER = 348,
CLASS_NO_EXPANSION = 349,
CLASS_FIXED = 350,
ISPROPSET = 351,
CLASS_DEFAULT_PROPERTY = 352,
PROPERTY_CATEGORY = 353,
CLASS_DATA = 354,
CLASS_PROPERTY = 355,
SUBCLASS = 356,
NAMESPACE = 357,
NEW0OP = 358,
RENEW0 = 359,
VAARG = 360,
DBTABLE = 361,
DBFIELD = 362,
DBINDEX = 363,
DATABASE_OPEN = 364,
ALIGNOF = 365,
ATTRIB_DEP = 366,
__ATTRIB = 367,
BOOL = 368,
_BOOL = 369,
_COMPLEX = 370,
_IMAGINARY = 371,
RESTRICT = 372,
THREAD = 373,
WIDE_STRING_LITERAL = 374,
BUILTIN_OFFSETOF = 375,
PRAGMA = 376,
STATIC_ASSERT = 377
};
#endif
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE YYSTYPE;
union YYSTYPE
{
#line 39 "expression.y" /* yacc.c:372 */
int i;
AccessMode declMode;
SpecifierType specifierType;
Identifier id;
Expression exp;
Specifier specifier;
OldList * list;
Enumerator enumerator;
Declarator declarator;
Pointer pointer;
Initializer initializer;
InitDeclarator initDeclarator;
TypeName typeName;
Declaration declaration;
Statement stmt;
FunctionDefinition function;
External external;
Context context;
Attrib attrib;
ExtDecl extDecl;
Attribute attribute;
Instantiation instance;
MembersInit membersInit;
MemberInit memberInit;
ClassFunction classFunction;
ClassDefinition _class;
ClassDef classDef;
PropertyDef prop;
char * string;
Symbol symbol;
#line 296 "expression.ec" /* yacc.c:372 */
};
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
/* Location type. */
#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE YYLTYPE;
struct YYLTYPE
{
int first_line;
int first_column;
int last_line;
int last_column;
};
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif
extern YYSTYPE yylval;
extern YYLTYPE yylloc;
int yyparse (void);
/* Copy the second part of user declarations. */
#line 325 "expression.ec" /* yacc.c:375 */
#ifdef short
# undef short
#endif
#ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8;
#else
typedef unsigned char yytype_uint8;
#endif
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
#else
typedef signed char yytype_int8;
#endif
#ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16;
#else
typedef unsigned short int yytype_uint16;
#endif
#ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16;
#else
typedef short int yytype_int16;
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif ! defined YYSIZE_T
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# define YYSIZE_T unsigned int
# endif
#endif
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */
# if (! defined __GNUC__ || __GNUC__ < 2 \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
# define __attribute__(Spec) /* empty */
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif
#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
&& defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
YYLTYPE yyls_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ 2 * YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 155
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 7843
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 148
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 108
/* YYNRULES -- Number of rules. */
#define YYNRULES 436
/* YYNSTATES -- Number of states. */
#define YYNSTATES 758
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 377
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, without out-of-bounds checking. */
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 135, 2, 2, 125, 137, 130, 2,
123, 124, 131, 132, 129, 133, 126, 136, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 143, 145,
138, 144, 139, 142, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 127, 2, 128, 140, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 146, 141, 147, 134, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
115, 116, 117, 118, 119, 120, 121, 122
};
#if YYDEBUG
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
0, 220, 220, 225, 226, 231, 233, 235, 237, 238,
240, 241, 242, 245, 246, 247, 248, 249, 250, 251,
252, 253, 257, 261, 262, 263, 264, 265, 266, 279,
280, 281, 311, 312, 313, 314, 318, 319, 320, 323,
324, 327, 328, 332, 333, 342, 343, 344, 345, 346,
347, 348, 352, 353, 357, 358, 359, 360, 364, 365,
366, 370, 371, 372, 376, 377, 378, 379, 380, 384,
385, 386, 390, 391, 395, 396, 400, 401, 405, 406,
410, 411, 415, 416, 420, 421, 422, 424, 425, 429,
430, 431, 432, 433, 434, 435, 436, 437, 438, 439,
443, 444, 448, 452, 453, 454, 455, 459, 460, 461,
462, 463, 464, 465, 466, 470, 471, 472, 473, 474,
475, 476, 477, 478, 479, 484, 485, 486, 487, 488,
489, 490, 491, 495, 496, 497, 498, 499, 500, 501,
502, 503, 504, 508, 509, 513, 514, 518, 519, 520,
521, 522, 523, 527, 528, 529, 533, 534, 535, 540,
541, 542, 543, 544, 548, 549, 553, 554, 555, 559,
560, 564, 565, 568, 569, 570, 574, 599, 603, 604,
605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
628, 629, 630, 631, 632, 633, 634, 635, 636, 637,
638, 639, 640, 641, 642, 643, 644, 645, 646, 647,
648, 653, 654, 655, 656, 657, 660, 661, 662, 663,
664, 669, 670, 673, 675, 680, 681, 685, 686, 690,
694, 695, 699, 701, 703, 705, 707, 710, 712, 714,
716, 718, 721, 723, 725, 727, 729, 732, 734, 736,
738, 740, 745, 746, 747, 748, 749, 750, 751, 752,
756, 758, 763, 765, 767, 769, 771, 776, 777, 781,
783, 784, 785, 786, 790, 792, 797, 799, 801, 802,
807, 809, 811, 813, 815, 817, 819, 821, 823, 825,
827, 832, 834, 836, 838, 840, 845, 846, 847, 848,
849, 850, 854, 855, 856, 857, 858, 859, 905, 906,
908, 914, 916, 918, 920, 922, 927, 928, 931, 933,
935, 941, 942, 943, 945, 950, 954, 956, 958, 963,
964, 968, 969, 970, 971, 975, 976, 980, 981, 985,
986, 987, 991, 992, 996, 997, 1006, 1008, 1010, 1026,
1027, 1048, 1050, 1055, 1056, 1057, 1058, 1059, 1060, 1064,
1066, 1068, 1073, 1074, 1078, 1079, 1082, 1086, 1087, 1088,
1092, 1096, 1104, 1109, 1110, 1114, 1115, 1116, 1120, 1121,
1122, 1123, 1125, 1126, 1127, 1131, 1132, 1133, 1134, 1135,
1139, 1143, 1145, 1150, 1152, 1154, 1156, 1161, 1163, 1168,
1170, 1175, 1180, 1185, 1187, 1192, 1194, 1196, 1198, 1200,
1206, 1211, 1216, 1217, 1221, 1223, 1228, 1233, 1234, 1235,
1236, 1237, 1238, 1242, 1243, 1244, 1248
};
#endif
#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "IDENTIFIER", "CONSTANT",
"STRING_LITERAL", "SIZEOF", "PTR_OP", "INC_OP", "DEC_OP", "LEFT_OP",
"RIGHT_OP", "LE_OP", "GE_OP", "EQ_OP", "NE_OP", "AND_OP", "OR_OP",
"MUL_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "ADD_ASSIGN", "SUB_ASSIGN",
"LEFT_ASSIGN", "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN",
"TYPE_NAME", "TYPEDEF", "EXTERN", "STATIC", "AUTO", "REGISTER", "CHAR",
"SHORT", "INT", "UINT", "INT64", "INT128", "FLOAT128", "LONG", "SIGNED",
"UNSIGNED", "FLOAT", "DOUBLE", "CONST", "VOLATILE", "VOID", "VALIST",
"STRUCT", "UNION", "ENUM", "ELLIPSIS", "CASE", "DEFAULT", "IF", "SWITCH",
"WHILE", "DO", "FOR", "GOTO", "CONTINUE", "BREAK", "RETURN", "IFX",
"ELSE", "CLASS", "THISCLASS", "PROPERTY", "SETPROP", "GETPROP", "NEWOP",
"RENEW", "DELETE", "EXT_DECL", "EXT_STORAGE", "IMPORT", "DEFINE",
"VIRTUAL", "ATTRIB", "PUBLIC", "PRIVATE", "TYPED_OBJECT", "ANY_OBJECT",
"_INCREF", "EXTENSION", "ASM", "TYPEOF", "WATCH", "STOPWATCHING",
"FIREWATCHERS", "WATCHABLE", "CLASS_DESIGNER", "CLASS_NO_EXPANSION",
"CLASS_FIXED", "ISPROPSET", "CLASS_DEFAULT_PROPERTY",
"PROPERTY_CATEGORY", "CLASS_DATA", "CLASS_PROPERTY", "SUBCLASS",
"NAMESPACE", "NEW0OP", "RENEW0", "VAARG", "DBTABLE", "DBFIELD",
"DBINDEX", "DATABASE_OPEN", "ALIGNOF", "ATTRIB_DEP", "__ATTRIB", "BOOL",
"_BOOL", "_COMPLEX", "_IMAGINARY", "RESTRICT", "THREAD",
"WIDE_STRING_LITERAL", "BUILTIN_OFFSETOF", "PRAGMA", "STATIC_ASSERT",
"'('", "')'", "'$'", "'.'", "'['", "']'", "','", "'&'", "'*'", "'+'",
"'-'", "'~'", "'!'", "'/'", "'%'", "'<'", "'>'", "'^'", "'|'", "'?'",
"':'", "'='", "';'", "'{'", "'}'", "$accept", "identifier",
"primary_expression", "simple_primary_expression",
"anon_instantiation_expression", "postfix_expression",
"argument_expression_list", "common_unary_expression",
"unary_expression", "unary_operator", "cast_expression",
"multiplicative_expression", "additive_expression", "shift_expression",
"relational_expression", "equality_expression", "and_expression",
"exclusive_or_expression", "inclusive_or_expression",
"logical_and_expression", "logical_or_expression",
"conditional_expression", "assignment_expression", "assignment_operator",
"expression", "constant_expression", "declaration",
"specifier_qualifier_list", "declaration_specifiers",
"property_specifiers", "renew_specifiers", "init_declarator_list",
"init_declarator", "storage_class_specifier", "ext_decl", "_attrib",
"attribute_word", "attribute", "attribs_list", "attrib", "multi_attrib",
"type_qualifier", "type", "strict_type", "type_specifier",
"strict_type_specifier", "struct_or_union_specifier_compound",
"struct_or_union_specifier_nocompound", "struct_or_union",
"struct_declaration_list", "default_property", "default_property_list",
"property", "struct_declaration", "struct_declarator_list",
"struct_declarator", "enum_specifier_nocompound",
"enum_specifier_compound", "enumerator_list", "enumerator",
"direct_abstract_declarator", "direct_abstract_declarator_noarray",
"abstract_declarator", "abstract_declarator_noarray", "declarator",
"direct_declarator_nofunction", "declarator_function",
"direct_declarator", "direct_declarator_function_start",
"direct_declarator_function", "type_qualifier_list", "pointer",
"parameter_type_list", "parameter_list", "parameter_declaration",
"identifier_list", "type_name", "initializer", "initializer_condition",
"initializer_list", "statement", "labeled_statement", "declaration_list",
"statement_list", "compound_inside", "compound_start",
"compound_statement", "expression_statement", "selection_statement",
"iteration_statement", "jump_statement", "string_literal",
"instantiation_named", "instantiation_unnamed", "instantiation_anon",
"class_function_definition_start",
"constructor_function_definition_start",
"destructor_function_definition_start",
"virtual_class_function_definition_start", "class_function_definition",
"instance_class_function_definition_start",
"instance_class_function_definition", "data_member_initialization",
"data_member_initialization_list",
"data_member_initialization_list_coloned",
"members_initialization_list_coloned", "members_initialization_list",
"expression_unit", YY_NULL
};
#endif
# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
(internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
375, 376, 377, 40, 41, 36, 46, 91, 93, 44,
38, 42, 43, 45, 126, 33, 47, 37, 60, 62,
94, 124, 63, 58, 61, 59, 123, 125
};
# endif
#define YYPACT_NINF -645
#define yypact_value_is_default(Yystate) \
(!!((Yystate) == (-645)))
#define YYTABLE_NINF -434
#define yytable_value_is_error(Yytable_value) \
0
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
static const yytype_int16 yypact[] =
{
5781, -645, -645, -645, -645, 5815, 5889, 5889, -645, 7543,
5781, -645, 7543, 5781, 5923, -645, 5373, 124, -645, -645,
-645, -645, -645, -645, 17, -645, -645, 452, -645, 719,
5781, -645, 273, -26, 303, 48, 370, 54, -9, 78,
181, 2, 719, -645, 86, -645, -645, -645, 282, 5373,
-645, 5525, -645, -645, -645, -645, -645, -645, -645, -645,
-645, -645, -645, -645, -645, -645, -645, -645, -645, -645,
-645, -645, -645, -645, -645, -645, -645, 10, -645, -645,
-645, 150, -645, -645, -645, 6544, -645, -645, -645, -645,
-645, -645, 24, -645, -645, -645, -645, 7725, 6648, 7725,
5373, -645, -645, -645, -49, 7058, -645, 86, -645, -645,
-645, 164, 173, 2017, 298, -645, -645, 1411, 298, 5781,
-645, -645, -645, -645, -645, -645, -645, -645, -645, -645,
-645, -645, 4374, -645, 5781, 5781, 5781, 5781, 5781, 5781,
5781, 5781, 5781, 5781, 5781, 5781, 5781, 5781, 5781, 5781,
5781, 5781, 5781, 4374, 2152, -645, 183, 298, 175, 182,
344, -645, -645, -645, -645, 6752, 5781, 199, -645, -15,
243, 147, 167, -645, -645, -645, -645, 251, 278, 253,
2680, 277, 20, 281, -645, -645, -645, -645, -645, -645,
-645, -645, -645, -645, -645, -645, -645, -645, -645, 306,
-645, -645, 6856, -645, -645, -645, -645, -645, -645, -645,
-645, 5781, 322, 6960, 354, -645, 5781, 6440, 5559, 392,
-645, -645, -645, -645, 83, -645, 270, 5781, 124, -645,
2287, -645, -645, 350, -645, 6239, -645, -645, 319, -645,
-645, -61, -645, 2422, 337, -645, -645, -645, 220, -645,
-645, 371, -645, -645, -645, -645, -645, 273, 273, -26,
-26, 303, 303, 303, 303, 48, 48, 370, 54, -9,
78, 181, -66, -645, -645, -645, 369, -645, 97, -59,
-645, 298, 298, 377, -645, 6135, 386, 394, 395, -645,
403, -645, 199, -645, 251, 253, 399, -645, 7162, 5781,
251, 7634, 6239, 5447, 7543, -645, -645, 17, 439, 5004,
37, 2803, -645, 94, -645, -645, 284, -645, 6343, -645,
290, 401, 402, 319, 319, 319, 341, -645, 2926, 3049,
388, 404, 4632, 344, 5781, -645, -645, -645, -645, -645,
411, 421, 5781, 5781, 424, -645, -645, -645, 428, 429,
-645, 426, -54, 83, 270, 7259, 5599, 83, -645, -645,
-645, 412, 4374, 140, -645, -645, 413, 4222, -645, 4374,
-645, -645, -645, -61, -645, -645, -645, 4374, -645, 5781,
-645, 5781, -645, 280, 298, -645, 66, 177, -645, 6031,
52, -645, -645, 284, -645, -645, 308, -645, -645, 7452,
-645, -645, -645, 251, 263, -645, 434, 435, 53, 4885,
-645, -645, -645, -645, 358, 6239, -645, 5238, 538, 37,
437, 290, 7356, 4374, 433, 5781, -645, 422, 37, 111,
-645, 363, -645, 423, 290, -645, 59, -645, -645, 1104,
-645, -645, 5633, -645, -645, 443, 223, 59, -645, -645,
-645, -645, -645, -645, -645, -645, -645, 3172, -645, 3295,
3418, 4632, 3541, 446, 448, 5781, -645, 459, 461, 5781,
-645, -645, -645, -645, 83, -645, 450, -645, 462, 107,
-645, -645, -645, 5781, 449, 468, 474, 476, 4357, 477,
298, 456, 458, 4767, 298, -645, 197, 120, -645, 5122,
-645, -645, 1612, 1747, 460, -645, -645, -645, -645, -645,
466, -645, -645, -645, -645, -645, 5781, -645, 4632, -645,
4632, -645, 284, -645, 308, 59, -645, -645, -645, -645,
-645, -645, -645, -645, 491, 493, -645, 222, -645, -645,
-645, -645, -17, 471, -645, -645, -645, -645, 28, -645,
53, -645, -645, 290, -645, 495, -645, -645, -645, 2557,
475, 290, 225, -645, 5781, -645, 59, 479, -645, -645,
-645, 499, 115, -645, -645, 298, -645, -645, -645, -645,
3664, 3787, -645, -645, -645, 501, -645, -645, 502, -645,
-645, -645, 480, 4357, 5781, 5781, 5707, 574, 4686, 488,
-645, -645, -645, 151, 494, 4357, -645, -645, 250, -645,
496, -645, 1882, -645, -645, -645, -645, -645, 3910, 4033,
-645, -645, 5781, 511, 436, -645, 319, 319, -645, 31,
163, 497, -645, -645, -645, -645, 490, 498, -645, 504,
505, -645, -645, -645, -645, -645, -645, -645, 4357, -645,
301, 316, 4357, 328, 519, 4357, 4719, -645, -645, 5781,
-645, 140, -645, 4509, -645, -645, 338, -645, -645, 12,
-36, 319, 319, -645, 319, 319, -645, 249, -645, 5781,
-645, 4357, 4357, -645, 4357, 5781, -645, 4357, 5741, 500,
-645, 4509, -645, -645, -645, 319, -645, 319, -645, 42,
-5, 44, 8, 319, 319, -645, -645, 587, -645, -645,
342, -645, 4357, 356, -645, -645, 194, 507, 510, 319,
-645, 319, -645, 319, -645, 319, -645, 77, 25, 4357,
520, -645, 4357, 4087, -645, -645, -645, 521, 523, 528,
531, 319, -645, 319, -645, -645, -645, -645, -645, -645,
-645, -645, -645, -645, 532, 533, -645, -645
};
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do. Zero
means the default is an error. */
static const yytype_uint16 yydefact[] =
{
0, 21, 2, 7, 400, 0, 0, 0, 177, 0,
0, 51, 0, 0, 0, 8, 0, 0, 45, 46,
47, 48, 49, 50, 5, 23, 3, 44, 43, 52,
0, 54, 58, 61, 64, 69, 72, 74, 76, 78,
80, 82, 84, 436, 0, 176, 9, 6, 0, 0,
39, 0, 36, 37, 147, 148, 149, 150, 151, 179,
180, 181, 182, 183, 184, 185, 187, 190, 191, 188,
189, 173, 174, 178, 186, 235, 236, 0, 199, 175,
192, 0, 194, 193, 152, 0, 115, 117, 197, 119,
123, 195, 0, 196, 121, 52, 102, 0, 0, 0,
0, 41, 12, 100, 0, 354, 107, 197, 109, 113,
111, 0, 10, 0, 0, 30, 31, 0, 0, 0,
28, 90, 91, 92, 93, 94, 95, 96, 97, 98,
99, 89, 0, 38, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 277, 278,
0, 153, 156, 157, 158, 0, 0, 341, 116, 0,
0, 154, 155, 118, 120, 124, 122, 313, 0, 312,
0, 231, 0, 232, 201, 202, 203, 204, 205, 206,
207, 209, 212, 213, 210, 211, 200, 208, 220, 0,
215, 214, 0, 133, 135, 218, 137, 139, 216, 217,
141, 0, 0, 0, 0, 4, 0, 0, 0, 0,
108, 110, 114, 112, 307, 355, 306, 0, 0, 431,
0, 406, 360, 44, 359, 0, 423, 22, 0, 428,
424, 434, 427, 0, 0, 29, 25, 33, 0, 32,
27, 0, 87, 85, 55, 56, 57, 59, 60, 62,
63, 67, 68, 65, 66, 70, 71, 73, 75, 77,
79, 81, 0, 88, 86, 404, 0, 40, 286, 0,
284, 0, 0, 0, 302, 351, 0, 0, 345, 347,
0, 339, 342, 343, 316, 315, 0, 172, 0, 0,
314, 0, 0, 0, 0, 269, 224, 5, 0, 0,
0, 0, 240, 0, 268, 237, 0, 410, 0, 326,
0, 0, 6, 0, 0, 0, 0, 266, 0, 0,
233, 234, 0, 0, 0, 134, 136, 138, 140, 142,
0, 0, 0, 0, 0, 42, 101, 297, 0, 0,
291, 0, 0, 310, 309, 0, 0, 308, 53, 11,
408, 0, 0, 0, 321, 420, 380, 0, 421, 0,
426, 432, 430, 435, 429, 405, 26, 0, 24, 0,
403, 0, 171, 288, 0, 279, 0, 0, 198, 0,
0, 350, 349, 332, 318, 331, 306, 301, 303, 0,
14, 340, 344, 317, 0, 304, 0, 0, 0, 0,
125, 127, 131, 129, 0, 0, 414, 0, 46, 0,
0, 0, 0, 0, 0, 0, 263, 321, 0, 0,
270, 272, 409, 331, 0, 328, 0, 222, 238, 0,
267, 335, 0, 338, 352, 0, 0, 0, 327, 265,
264, 415, 418, 419, 417, 416, 223, 0, 229, 0,
0, 0, 0, 0, 0, 0, 16, 0, 0, 0,
290, 298, 292, 293, 311, 299, 0, 294, 0, 0,
407, 422, 381, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 383, 5, 0, 372, 0,
374, 363, 0, 0, 0, 364, 365, 366, 367, 368,
0, 425, 35, 34, 83, 287, 0, 285, 0, 280,
0, 283, 334, 333, 309, 0, 319, 346, 348, 159,
160, 163, 162, 161, 0, 164, 166, 0, 305, 13,
277, 278, 0, 0, 126, 128, 132, 130, 0, 231,
0, 232, 413, 0, 322, 0, 239, 411, 274, 0,
333, 0, 0, 262, 0, 273, 0, 331, 329, 241,
324, 0, 0, 336, 337, 0, 330, 221, 227, 228,
0, 0, 225, 219, 18, 0, 15, 20, 0, 300,
295, 296, 0, 0, 0, 0, 0, 0, 0, 0,
396, 397, 398, 0, 0, 0, 384, 103, 0, 143,
145, 373, 0, 376, 375, 382, 105, 289, 0, 0,
320, 170, 0, 0, 0, 167, 0, 0, 256, 0,
0, 0, 233, 234, 412, 402, 0, 331, 271, 275,
333, 323, 325, 353, 226, 230, 17, 19, 0, 371,
0, 0, 0, 0, 0, 0, 0, 395, 399, 0,
369, 0, 104, 0, 281, 282, 0, 169, 168, 0,
0, 0, 0, 246, 0, 0, 261, 0, 401, 0,
370, 0, 0, 392, 0, 0, 394, 0, 0, 0,
144, 0, 356, 146, 165, 0, 254, 0, 255, 0,
0, 0, 0, 0, 0, 251, 276, 385, 387, 388,
0, 393, 0, 0, 106, 361, 0, 0, 0, 0,
244, 0, 245, 0, 259, 0, 260, 0, 0, 0,
0, 390, 0, 0, 357, 252, 253, 0, 0, 0,
0, 0, 249, 0, 250, 386, 389, 391, 358, 362,
242, 243, 257, 258, 0, 0, 247, 248
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
-645, 391, -645, -645, -108, 708, -645, -645, 0, -645,
-13, 389, 393, 348, 390, 536, 541, 518, 540, 544,
-645, 72, 1, 654, -14, 56, -335, -645, 27, -645,
598, -645, 43, 219, 816, -645, -645, -496, -645, -154,
420, 1090, 782, -33, 41, -93, 187, -6, -275, -256,
264, -645, -645, -286, -645, 143, -1, 561, 261, 323,
-197, -158, -97, 29, -281, 1048, -215, -363, -645, 1034,
-645, -55, -153, -645, 307, -645, -3, -644, -320, -645,
174, -645, -645, 206, -645, -645, 664, -531, -645, -645,
-645, -7, -352, 695, -645, -645, -645, -645, -645, -645,
-645, 467, 345, 470, 473, -645, -151, -645
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
-1, 24, 25, 26, 232, 27, 248, 28, 95, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 103, 132, 497, 97, 613, 105, 309, 409,
202, 608, 609, 86, 310, 170, 535, 536, 537, 171,
172, 87, 44, 45, 89, 206, 90, 91, 92, 311,
312, 313, 314, 315, 429, 430, 93, 94, 279, 280,
224, 177, 348, 178, 420, 316, 317, 394, 318, 319,
292, 320, 349, 288, 289, 446, 111, 693, 236, 716,
500, 501, 502, 503, 504, 367, 505, 506, 507, 508,
509, 46, 321, 47, 237, 323, 324, 325, 326, 327,
238, 239, 240, 241, 242, 243, 244, 48
};
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule whose
number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int16 yytable[] =
{
29, 43, 104, 276, 392, 50, 52, 53, 225, 247,
112, 294, 287, 2, 101, 510, 29, 133, 297, 151,
365, 300, 353, 2, 252, 438, 414, 2, 431, 357,
179, 2, 498, 526, 697, 104, 85, 104, 8, 98,
2, 625, 481, 179, 159, 273, 156, 715, 8, 29,
226, 29, 8, 626, 627, 2, 2, 108, 526, 183,
141, 142, 2, 216, 205, 721, 205, 656, 369, 99,
384, 526, 457, 459, 473, 215, 462, 379, 725, 361,
216, 8, 96, 695, 370, 96, 104, 416, 385, 749,
108, 208, 154, 208, 432, 743, 209, 214, 209, 161,
29, 671, 672, 556, 162, 251, 137, 138, 165, 337,
179, 698, 293, 719, 295, 723, 167, 29, 249, 29,
337, 254, 255, 256, 382, 688, 174, 212, 668, 4,
628, 148, 29, 253, 414, 163, 164, 403, 272, 174,
235, 108, 722, 2, 152, 406, 221, 179, 741, 331,
510, 510, 29, 29, 274, 726, 157, 474, 179, 696,
363, 620, 226, 113, 354, 445, 329, 611, 167, 205,
180, 438, 744, 438, 630, 389, 438, 162, 673, 218,
205, 235, 363, 167, 147, 234, 143, 144, 391, 720,
620, 724, 285, 353, 286, 384, 208, 150, 620, 357,
552, 209, 476, 109, 580, 581, 355, 208, 163, 164,
356, 518, 209, 519, 358, 161, 29, 346, 610, 149,
162, 359, 290, 439, 742, 529, 234, -171, 2, 297,
396, 340, 154, 674, 675, 591, 109, 402, 96, 440,
562, 381, 344, 642, 285, 71, 72, 162, 421, 216,
530, 163, 164, 154, 434, 436, 563, 235, -171, -171,
510, 154, 618, 363, 619, 606, 529, 341, 531, 512,
235, 167, 175, 160, 351, 79, 174, 565, 163, 164,
216, 431, 155, 96, 207, 175, 207, 109, 227, 104,
96, 530, 222, 2, 438, 438, 658, 532, 533, 228,
161, 2, 234, 29, 168, 162, 384, 277, 421, 531,
676, 2, 548, 139, 140, 234, 203, 168, 203, 703,
704, 281, 520, 733, 521, 285, 174, 474, 282, 415,
167, 422, 438, 438, 396, 524, 163, 164, 532, 533,
605, 734, 413, 113, 376, 285, 623, 574, 363, 377,
174, 624, 575, 2, 226, 407, 167, 114, 115, 116,
162, 2, 421, 293, 553, 161, 296, 29, 425, 421,
162, 96, 8, 561, 298, 541, 165, 29, 513, 661,
610, 551, 285, 161, 145, 146, 8, 534, 162, 338,
464, 163, 164, 217, 499, 662, 705, 218, 467, 468,
338, 163, 164, 104, 134, 299, 96, 441, 636, 135,
136, 442, 478, 363, 96, 96, 285, 29, 120, 163,
164, 335, 175, 328, 516, 681, 285, 332, 96, 333,
216, 389, 335, 161, 234, 218, 2, 515, 162, 529,
682, 234, 2, 162, 421, 216, 114, 115, 116, 342,
547, 514, 684, 96, 168, 2, 174, 216, 108, 114,
115, 116, 694, 174, 530, 366, 730, 216, 158, 163,
164, 216, 175, 117, 163, 164, 118, 119, 345, 603,
732, 558, 531, 181, 375, 216, 454, 366, 29, 261,
262, 263, 264, 29, 362, 234, 175, 96, 571, 378,
216, 388, 29, 29, 168, 245, 564, 421, 161, 250,
397, 532, 533, 162, 96, 217, 380, 633, 398, 218,
410, 585, 404, 167, 399, 588, 257, 258, 168, 499,
499, 400, 259, 260, 460, 265, 266, 96, 465, 592,
174, 96, 386, 387, 163, 164, 449, 450, 278, 466,
461, 469, 470, 471, 472, 96, 363, 557, 538, 480,
482, 554, 117, 539, 167, 118, 119, 573, 559, -326,
583, 307, 617, 330, 589, 117, 584, 110, 118, 119,
650, 651, 653, 423, 71, 72, 235, 586, 96, 587,
590, 594, 593, 29, 29, 29, 29, 595, 29, 596,
598, 600, 175, 601, 109, 29, 421, 615, 666, 175,
110, 616, 29, -341, 79, 621, 622, 629, -341, 634,
639, -328, 29, 648, 120, -327, 364, 641, 544, 646,
647, 234, 654, 657, 168, 667, 96, 678, 659, 499,
663, 168, 685, 677, -329, 714, 176, 679, 29, -341,
-341, -330, 29, 729, 735, 29, 29, 736, 210, 176,
210, 110, 597, 29, 692, 746, 223, 269, 750, 167,
751, 710, 278, 278, 713, 752, 364, 614, 753, 756,
757, 29, 29, 267, 29, 29, 175, 29, 29, 268,
270, 29, 692, 364, 307, 271, 153, 213, 383, 120,
427, 364, 307, 569, 690, 638, 528, 517, 612, 444,
372, 364, 29, 373, 511, 689, 374, 0, 168, 307,
307, 0, 0, 307, 0, 0, 0, 0, 0, 29,
0, 96, 29, 29, 692, 706, 0, 121, 122, 123,
124, 125, 126, 127, 128, 129, 130, 0, 0, 0,
0, 96, 0, 0, 364, 0, 0, 0, 496, 0,
0, 0, 0, 339, 0, 0, 0, 649, 0, 0,
0, 0, 0, 0, 339, 278, 0, 0, 0, 660,
364, 364, 0, 0, 0, 0, 614, 364, 0, 0,
0, 88, 0, 0, 88, 0, 176, 0, 107, 540,
543, 0, 0, 0, 0, 549, 364, 0, 307, 0,
364, 0, 364, 0, 0, 364, 0, 0, 0, 364,
0, 233, 680, 0, 0, 364, 683, 364, 0, 686,
0, 107, 0, 0, 0, 0, 0, 0, 364, 0,
0, 0, 0, 0, 0, 0, 176, 0, 307, 0,
307, 307, 307, 307, 0, 707, 708, 0, 709, 0,
0, 711, 233, 131, 0, 0, 0, 88, 0, 0,
176, 0, 0, 0, 0, 322, 0, 0, 0, 496,
88, 599, 107, 0, 0, 604, 731, 88, 308, 0,
427, 0, 0, 496, 496, 107, 0, 0, 0, 0,
0, 169, 368, 745, 0, 0, 747, 0, 182, 307,
0, 307, 0, 0, 169, 364, 364, 0, 0, 0,
0, 219, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 107, 0, 233, 631,
0, 632, 283, 0, 364, 0, 0, 88, 0, 0,
0, 233, 364, 364, 0, 0, 0, 364, 0, 0,
0, 0, 107, 0, 0, 0, 643, 0, 0, 0,
0, 307, 307, 0, 0, 0, 176, 0, 110, 0,
0, 169, 0, 176, 496, 0, 0, 451, 452, 453,
455, 0, 0, 0, 0, 0, 496, 0, 0, 88,
352, 0, 0, 496, 0, 0, 322, 0, 0, 307,
307, 0, 107, 0, 0, 0, 0, 88, 169, 308,
0, 0, 0, 322, 322, 107, 0, 322, 0, 169,
0, 0, 0, 219, 0, 0, 308, 308, 0, 496,
308, 0, 0, 496, 0, 0, 496, 0, 0, 0,
0, 0, 364, 0, 0, 0, 0, 0, 0, 0,
176, 0, 0, 0, 0, 0, 0, 88, 0, 0,
0, 0, 496, 496, 0, 496, 0, 233, 496, 0,
88, 0, 0, 412, 88, 0, 88, 0, 0, 0,
0, 88, 0, 107, 0, 0, 0, 0, 0, 0,
88, 390, 0, 496, 0, 1, 106, 2, 3, 4,
107, 107, 0, 0, 107, 463, 0, 0, 0, 419,
496, 0, 0, 496, 0, 428, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0, 447, 88, 479, 106,
0, 0, 0, 0, 0, 0, 0, 308, 0, 107,
0, 0, 322, 0, 322, 322, 322, 322, 0, 0,
0, 0, 0, 0, 0, 308, 0, 308, 308, 308,
308, 88, 0, 0, 0, 173, 9, 10, 0, 419,
0, 88, 0, 0, 0, 0, 0, 204, 173, 204,
106, 546, 0, 0, 0, 220, 0, 88, 0, 107,
0, 0, 0, 0, 88, 390, 0, 12, 13, 0,
0, 0, 525, 322, 0, 322, 0, 0, 0, 0,
0, 0, 0, 15, 572, 219, 308, 51, 308, 17,
550, 0, 0, 419, 0, 0, 0, 525, 0, 107,
419, 107, 107, 107, 107, 0, 0, 0, 0, 0,
566, 0, 0, 0, 0, 0, 0, 291, 0, 0,
0, 0, 0, 0, 0, 0, 0, 233, 0, 0,
0, 0, 0, 0, 0, 322, 322, 0, 0, 0,
0, 88, 0, 0, 107, 107, 0, 0, 308, 308,
669, 670, 336, 0, 0, 0, 0, 0, 0, 0,
107, 0, 107, 336, 0, 0, 0, 0, 0, 0,
0, 0, 0, 322, 322, 419, 0, 0, 0, 395,
0, 0, 0, 0, 0, 173, 308, 308, 0, 0,
0, 0, 0, 393, 0, 699, 700, 395, 701, 702,
525, 107, 0, 433, 435, 0, 0, 0, 0, 0,
0, 393, 0, 0, 448, 0, 0, 393, 0, 717,
0, 718, 107, 107, 0, 0, 0, 727, 728, 525,
0, 0, 0, 0, 0, 173, 0, 525, 419, 0,
0, 0, 401, 737, 0, 738, 0, 739, 0, 740,
0, 411, 0, 0, 107, 0, 0, 395, 0, 173,
107, 107, 0, 0, 0, 754, 0, 755, 0, 0,
0, 393, 1, 0, 2, 3, 4, 5, 0, 6,
7, 0, 0, 395, 523, 0, 0, 0, 0, 0,
395, 0, 0, 0, 0, 0, 0, 393, 522, 8,
0, 0, 0, 0, 393, 0, 0, 0, 0, 0,
0, 395, 0, 523, 0, 395, 0, 0, 395, 0,
0, 0, 560, 0, 0, 393, 0, 522, 567, 393,
568, 0, 393, 0, 0, 0, 522, 419, 0, 0,
0, 576, 393, 9, 10, 11, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 545,
0, 0, 0, 0, 0, 173, 0, 106, 291, 0,
0, 0, 173, 0, 12, 13, 0, 0, 0, 0,
0, 14, 0, 0, 0, 0, 0, 0, 0, 0,
15, 0, 0, 395, 16, 246, 17, 0, 0, 0,
0, 18, 19, 20, 21, 22, 23, 393, 0, 0,
0, 0, 0, 0, 0, 0, 0, 230, 395, 523,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 393, 522, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 395, 0, 173,
0, 0, 0, 0, 0, 637, 395, 0, 0, 0,
640, 393, 0, 0, 0, 0, 0, 0, 0, 393,
393, 0, 0, 1, 522, 2, 3, 4, 5, 0,
6, 7, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 483, 484, 485, 486,
487, 488, 489, 490, 491, 492, 493, 0, 0, 0,
78, 0, 0, 0, 9, 10, 11, 0, 79, 0,
494, 0, 0, 0, 0, 395, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 393,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 14, 0, 0, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 16, 0, 17, 0, 0,
0, 0, 18, 19, 20, 21, 22, 23, 1, 0,
2, 3, 4, 5, 0, 6, 7, 495, 366, -378,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 8, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
0, 483, 484, 485, 486, 487, 488, 489, 490, 491,
492, 493, 0, 0, 0, 78, 0, 0, 0, 9,
10, 11, 0, 79, 0, 494, 0, 0, 0, 0,
0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
82, 83, 0, 0, 0, 84, 15, 0, 0, 0,
16, 0, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 1, 0, 2, 3, 4, 5, 0,
6, 7, 495, 366, -377, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 483, 484, 485, 486,
487, 488, 489, 490, 491, 492, 493, 0, 0, 0,
78, 0, 0, 0, 9, 10, 11, 0, 79, 0,
494, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 14, 0, 0, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 16, 0, 17, 0, 0,
0, 0, 18, 19, 20, 21, 22, 23, 1, 0,
2, 3, 4, 5, 0, 6, 7, 495, 366, -379,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 8, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 78, 0, 0, 0, 9,
10, 11, 0, 79, 0, 0, 0, 0, 0, 0,
0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
82, 83, 0, 0, 0, 84, 15, 0, 0, 0,
16, 0, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 1, 0, 2, 3, 4, 5, 0,
6, 7, 229, 230, 231, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 9, 10, 11, 0, 79, 0,
0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 14, 0, 0, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 16, 0, 17, 0, 0,
0, 0, 18, 19, 20, 21, 22, 23, 1, 0,
2, 3, 4, 5, 0, 6, 7, 229, 230, 275,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 8, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 78, 0, 0, 0, 9,
10, 11, 0, 79, 0, 0, 0, 0, 0, 0,
0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
82, 83, 0, 0, 0, 84, 15, 0, 0, 0,
16, 0, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 1, 0, 2, 3, 4, 5, 0,
6, 7, 229, 230, 360, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 9, 10, 11, 0, 79, 0,
0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 14, 0, 0, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 16, 0, 17, 0, 0,
0, 0, 18, 19, 20, 21, 22, 23, 1, 0,
2, 3, 4, 5, 0, 6, 7, 371, 230, -433,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 8, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 78, 0, 0, 0, 9,
10, 11, 0, 79, 0, 0, 0, 0, 0, 0,
0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
82, 83, 0, 0, 0, 84, 15, 0, 0, 0,
16, 1, 17, 2, 3, 4, 0, 18, 19, 20,
21, 22, 23, 0, 0, 0, 0, 0, 0, 0,
0, 0, 229, 230, 635, 0, 0, 0, 8, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 78, 301,
0, 0, 9, 10, 0, 161, 79, 0, 0, 302,
162, 0, 0, 0, 0, 0, 80, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 81, 0, 12, 13, 0, 0, 0, 0, 0,
0, 163, 164, 82, 83, 0, 0, 0, 84, 15,
0, 0, 0, 303, 1, 17, 2, 3, 4, 0,
0, 167, 0, 0, 304, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 305, 0, 306, 0, 0,
0, 8, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 78, 301, 0, 0, 9, 10, 0, 161, 79,
0, 0, 302, 162, 0, 0, 0, 0, 0, 80,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 81, 0, 12, 13, 0, 0,
0, 0, 0, 0, 163, 164, 82, 83, 0, 0,
0, 84, 15, 0, 0, 0, 303, 1, 17, 2,
3, 4, 0, 0, 167, 0, 0, 304, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 305, 0,
437, 0, 0, 0, 8, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 70, 71, 72, 73, 74, 75, 76, 77, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 78, 301, 0, 0, 9, 10,
0, 161, 79, 0, 0, 302, 162, 0, 0, 0,
0, 0, 80, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 81, 0, 12,
13, 0, 0, 0, 0, 0, 0, 163, 164, 82,
83, 0, 0, 0, 84, 15, 0, 0, 0, 303,
1, 17, 2, 3, 4, 0, 0, 167, 0, 0,
304, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 305, 0, 456, 0, 0, 0, 8, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
76, 77, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 78, 301, 0,
0, 9, 10, 0, 161, 79, 0, 0, 302, 162,
0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81, 0, 12, 13, 0, 0, 0, 0, 0, 0,
163, 164, 82, 83, 0, 0, 0, 84, 15, 0,
0, 0, 303, 1, 17, 2, 3, 4, 0, 0,
167, 0, 0, 304, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 305, 0, 458, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 301, 0, 0, 9, 10, 0, 161, 79, 0,
0, 302, 162, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 0, 163, 164, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 303, 1, 17, 2, 3,
4, 0, 0, 167, 0, 0, 304, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 305, 0, 577,
0, 0, 0, 8, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 77, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 78, 301, 0, 0, 9, 10, 0,
161, 79, 0, 0, 302, 162, 0, 0, 0, 0,
0, 80, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 81, 0, 12, 13,
0, 0, 0, 0, 0, 0, 163, 164, 82, 83,
0, 0, 0, 84, 15, 0, 0, 0, 303, 1,
17, 2, 3, 4, 0, 0, 167, 0, 0, 304,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
305, 0, 578, 0, 0, 0, 8, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 78, 301, 0, 0,
9, 10, 0, 161, 79, 0, 0, 302, 162, 0,
0, 0, 0, 0, 80, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
0, 12, 13, 0, 0, 0, 0, 0, 0, 163,
164, 82, 83, 0, 0, 0, 84, 15, 0, 0,
0, 303, 1, 17, 2, 3, 4, 0, 0, 167,
0, 0, 304, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 305, 0, 579, 0, 0, 0, 8,
54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 78,
301, 0, 0, 9, 10, 0, 161, 79, 0, 0,
302, 162, 0, 0, 0, 0, 0, 80, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 81, 0, 12, 13, 0, 0, 0, 0,
0, 0, 163, 164, 82, 83, 0, 0, 0, 84,
15, 0, 0, 0, 303, 1, 17, 2, 3, 4,
0, 0, 167, 0, 0, 304, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 305, 0, 582, 0,
0, 0, 8, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 78, 301, 0, 0, 9, 10, 0, 161,
79, 0, 0, 302, 162, 0, 0, 0, 0, 0,
80, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 81, 0, 12, 13, 0,
0, 0, 0, 0, 0, 163, 164, 82, 83, 0,
0, 0, 84, 15, 0, 0, 0, 303, 1, 17,
2, 3, 4, 0, 0, 167, 0, 0, 304, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 305,
0, 644, 0, 0, 0, 8, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 78, 301, 0, 0, 9,
10, 0, 161, 79, 0, 0, 302, 162, 0, 0,
0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 81, 0,
12, 13, 0, 0, 0, 0, 0, 0, 163, 164,
82, 83, 0, 0, 0, 84, 15, 0, 0, 0,
303, 1, 17, 2, 3, 4, 0, 0, 167, 0,
0, 304, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 305, 0, 645, 0, 0, 0, 8, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 78, 301,
0, 0, 9, 10, 0, 161, 79, 0, 0, 302,
162, 0, 0, 0, 0, 0, 80, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 81, 0, 12, 13, 0, 0, 0, 0, 0,
0, 163, 164, 82, 83, 0, 0, 0, 84, 15,
0, 0, 0, 303, 1, 17, 2, 3, 4, 0,
0, 167, 0, 0, 304, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 305, 0, 664, 0, 0,
0, 8, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 0, 0, 1, 0,
2, 3, 4, 5, 0, 6, 7, 0, 0, 0,
0, 78, 301, 0, 0, 9, 10, 0, 161, 79,
0, 0, 302, 162, 0, 8, 0, 0, 0, 80,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 81, 0, 12, 13, 0, 0,
0, 0, 0, 0, 163, 164, 82, 83, 0, 0,
0, 84, 15, 0, 0, 0, 303, 0, 17, 9,
10, 11, 0, 0, 167, 0, 0, 304, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 305, 0,
665, 0, 0, 0, 0, 0, 0, 0, 0, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
0, 0, 0, 0, 0, 0, 15, 0, 0, 0,
16, 0, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 1, 0, 2, 3, 4, 5, 0,
6, 7, 0, 691, 748, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 483, 484, 485, 486,
487, 488, 489, 490, 491, 492, 493, 0, 0, 0,
78, 0, 0, 0, 9, 10, 11, 0, 79, 0,
494, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 14, 0, 0, 82, 83, 0, 0, 0,
84, 15, 0, 0, 0, 16, 0, 17, 0, 0,
0, 0, 18, 19, 20, 21, 22, 23, 1, 0,
2, 3, 4, 5, 0, 6, 7, 495, 366, 0,
0, 0, 0, 0, 0, 1, 0, 2, 3, 4,
5, 0, 6, 7, 0, 8, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
0, 483, 484, 485, 486, 487, 488, 489, 490, 491,
492, 493, 0, 0, 0, 0, 0, 0, 0, 9,
10, 11, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 9, 10, 11, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
0, 0, 0, 0, 0, 0, 15, 12, 13, 0,
16, 0, 17, 0, 14, 0, 0, 18, 19, 20,
21, 22, 23, 15, 0, 0, 0, 16, 0, 17,
0, 0, 495, 366, 18, 19, 20, 21, 22, 23,
1, 0, 2, 3, 4, 5, 0, 6, 7, 0,
230, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 8, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 9, 10, 11, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 12, 13, 0, 0, 0, 0, 0, 14,
0, 0, 0, 0, 0, 0, 0, 0, 15, 0,
0, 0, 16, 1, 17, 2, 3, 4, 0, 18,
19, 20, 21, 22, 23, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 691, 0, 0, 0, 0,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 1, 0, 2,
3, 4, 5, 0, 6, 7, 0, 0, 0, 0,
78, 301, 0, 0, 9, 10, 0, 161, 79, 0,
0, 302, 162, 0, 8, 0, 0, 0, 80, 0,
1, 0, 2, 3, 4, 5, 0, 6, 7, 0,
0, 0, 0, 81, 0, 12, 13, 0, 0, 0,
0, 0, 0, 163, 164, 82, 83, 8, 0, 0,
84, 15, 0, 0, 0, 303, 0, 17, 9, 10,
11, 0, 0, 167, 0, 0, 304, 0, 1, 0,
2, 3, 4, 5, 0, 6, 7, 305, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 12,
13, 9, 10, 11, 0, 8, 14, 0, 0, 0,
0, 0, 0, 0, 0, 15, 0, 0, 0, 16,
655, 17, 0, 0, 0, 0, 18, 19, 20, 21,
22, 23, 12, 13, 0, 0, 0, 0, 0, 14,
0, 495, 0, 0, 0, 0, 0, 0, 15, 9,
10, 11, 16, 687, 17, 0, 0, 0, 0, 18,
19, 20, 21, 22, 23, 0, 0, 0, 0, 0,
0, 0, 0, 0, 495, 0, 0, 0, 0, 0,
12, 13, 0, 0, 0, 0, 0, 14, 0, 0,
0, 0, 0, 0, 0, 0, 15, 0, 2, 0,
16, 0, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 0, 0, 0, 0, 0, 0, 0,
0, 0, 602, 8, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 408, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 78, 0, 0, 0, 0, 0, 0,
161, 79, 0, 0, 0, 162, 0, 0, 0, 0,
0, 80, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 81, 0, 0, 0,
0, 0, 0, 0, 0, 0, 163, 164, 82, 83,
0, 0, 0, 84, 0, 0, 0, 2, 217, 0,
0, 0, 218, 0, 0, 0, 167, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 542, 8, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 78, 0, 0, 0, 0, 0, 0, 161,
79, 0, 0, 0, 162, 0, 0, 0, 0, 0,
80, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 81, 0, 0, 0, 0,
0, 0, 0, 0, 0, 163, 164, 82, 83, 0,
0, 0, 84, 0, 0, 2, 0, 424, 0, 0,
0, 0, 0, 0, 0, 167, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 425, 0, 426,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 0, 0, 0, 161, 79, 0,
0, 0, 162, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 0, 0, 0, 0, 0,
0, 0, 0, 163, 164, 82, 83, 0, 0, 1,
84, 2, 3, 4, 5, 363, 6, 7, 0, 0,
0, 0, 0, 167, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 8, 607, 0, 0,
0, 0, 59, 60, 61, 62, 63, 64, 65, 66,
67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 78, 0, 0, 0,
9, 10, 11, 161, 79, 0, 0, 0, 162, 0,
0, 0, 0, 0, 80, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
0, 12, 13, 0, 0, 0, 0, 0, 14, 163,
164, 82, 83, 0, 0, 0, 0, 15, 0, 0,
0, 417, 102, 17, 0, 0, 0, 0, 18, 418,
20, 21, 22, 23, 1, 0, 2, 3, 4, 5,
0, 6, 7, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 8, 0, 0, 0, 0, 0, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 78, 0, 0, 0, 9, 10, 11, 1, 79,
2, 3, 4, 5, 0, 6, 7, 0, 0, 80,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 81, 8, 12, 13, 0, 0,
0, 0, 0, 14, 0, 0, 82, 83, 0, 0,
0, 0, 15, 0, 0, 0, 16, 102, 17, 0,
0, 0, 0, 18, 19, 20, 21, 22, 23, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
10, 11, 161, 0, 0, 0, 1, 162, 2, 3,
4, 5, 0, 6, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
12, 13, 0, 8, 0, 0, 0, 14, 163, 164,
1, 0, 2, 3, 4, 5, 15, 6, 7, 0,
417, 102, 17, 0, 0, 0, 0, 18, 418, 20,
21, 22, 23, 0, 0, 0, 0, 8, 0, 0,
0, 0, 0, 0, 0, 0, 0, 9, 10, 11,
1, 0, 2, 3, 4, 5, 0, 6, 7, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 8, 12, 13,
0, 9, 10, 11, 1, 14, 2, 3, 4, 5,
0, 6, 7, 0, 15, 0, 0, 0, 16, 102,
17, 0, 0, 0, 0, 18, 19, 20, 21, 22,
23, 8, 12, 13, 0, 0, 0, 0, 0, 14,
0, 9, 10, 11, 0, 0, 0, 0, 15, 0,
0, 0, 16, 0, 17, 0, 0, 350, 0, 18,
19, 20, 21, 22, 23, 0, 0, 0, 0, 0,
0, 0, 12, 13, 0, 9, 10, 11, 1, 14,
2, 3, 4, 5, 0, 6, 7, 0, 15, 0,
0, 0, 16, 0, 17, 0, 0, 477, 0, 18,
19, 20, 21, 22, 23, 8, 12, 13, 0, 0,
0, 0, 1, 14, 2, 3, 4, 5, 0, 6,
7, 0, 15, 0, 0, 0, 16, 0, 17, 0,
0, 570, 0, 18, 19, 20, 21, 22, 23, 8,
0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
10, 11, 1, 0, 2, 3, 4, 5, 0, 6,
7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 8,
12, 13, 0, 9, 10, 11, 1, 14, 2, 3,
4, 5, 0, 6, 7, 0, 15, 0, 0, 0,
16, 652, 17, 0, 0, 0, 0, 18, 19, 20,
21, 22, 23, 8, 12, 13, 0, 0, 0, 0,
0, 14, 0, 9, 10, 11, 0, 0, 0, 0,
15, 0, 0, 0, 16, 712, 17, 0, 0, 0,
0, 18, 19, 20, 21, 22, 23, 0, 0, 0,
0, 0, 0, 0, 12, 13, 0, 9, 10, 11,
1, 14, 2, 3, 4, 5, 0, 6, 7, 0,
15, 0, 0, 0, 16, 0, 17, 0, 0, 0,
0, 18, 19, 20, 21, 22, 23, 8, 12, 13,
0, 0, 0, 0, 1, 14, 2, 3, 4, 5,
0, 6, 7, 0, 15, 0, 0, 0, 49, 0,
17, 0, 0, 0, 0, 18, 19, 20, 21, 22,
23, 8, 0, 0, 0, 0, 0, 0, 0, 0,
0, 9, 10, 11, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 12, 13, 0, 9, 10, 11, 0, 14,
0, 0, 0, 0, 0, 0, 0, 0, 15, 0,
0, 0, 51, 0, 17, 0, 0, 0, 0, 18,
19, 20, 21, 22, 23, 0, 12, 13, 0, 0,
0, 0, 0, 14, 2, 0, 0, 0, 0, 0,
0, 0, 15, 0, 0, 0, 100, 0, 17, 0,
0, 0, 0, 18, 19, 20, 21, 22, 23, 8,
54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 78,
0, 0, 0, 0, 0, 0, 161, 79, 0, 0,
0, 162, 0, 0, 0, 0, 0, 80, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 81, 0, 0, 0, 0, 0, 2, 0,
0, 0, 163, 164, 82, 83, 0, 0, 0, 84,
0, 0, 0, 0, 389, 347, 0, 0, 218, 0,
0, 0, 167, 8, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
70, 71, 72, 73, 74, 75, 76, 77, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 78, 0, 0, 0, 0, 0, 0,
161, 79, 0, 0, 0, 162, 0, 0, 0, 0,
0, 80, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 81, 0, 0, 0,
0, 0, 2, 0, 0, 0, 163, 164, 82, 83,
0, 0, 0, 84, 0, 0, 0, 0, 389, 0,
0, 0, 218, 0, 0, 0, 167, 8, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
76, 77, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 78, 0, 0,
0, 0, 0, 0, 161, 79, 0, 0, 0, 162,
0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81, 0, 0, 0, 0, 0, 2, 0, 0, 0,
163, 164, 82, 83, 0, 0, 0, 84, 0, 0,
0, 0, 363, 0, 0, 0, 0, 0, 0, 0,
167, 8, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 78, 0, 0, 0, 0, 0, 0, 0, 79,
0, 0, 0, 0, 0, 0, 0, 0, 0, 80,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 81, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 82, 83, 0, 0,
0, 84, 0, 0, 0, 0, 0, 443, 8, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 78, 0,
0, 0, 0, 0, 0, 161, 79, 0, 0, 0,
162, 0, 0, 0, 0, 0, 80, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 81, 0, 0, 0, 0, 0, 0, 0, 0,
0, 163, 164, 82, 83, 0, 0, 0, 84, 0,
0, 0, 0, 217, 347, 0, 0, 218, 0, 0,
0, 167, 8, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 77, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 78, 0, 0, 0, 0, 0, 0, 161,
79, 0, 0, 0, 162, 0, 0, 0, 0, 0,
80, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 81, 0, 0, 0, 0,
0, 0, 0, 0, 0, 163, 164, 82, 83, 0,
0, 0, 84, 0, 0, 0, 0, 165, 0, 0,
0, 166, 0, 0, 0, 167, 8, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65, 66,
67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 78, 0, 0, 0,
0, 0, 0, 161, 79, 0, 0, 0, 162, 0,
0, 0, 0, 0, 80, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
0, 0, 0, 0, 0, 0, 0, 0, 0, 163,
164, 82, 83, 0, 0, 0, 84, 0, 0, 0,
0, 165, 0, 0, 0, 211, 0, 0, 0, 167,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 0, 0, 0, 161, 79, 0,
0, 0, 162, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 0, 0, 0, 0, 0,
0, 0, 0, 163, 164, 82, 83, 0, 0, 0,
84, 0, 0, 0, 0, 165, 284, 0, 0, 0,
0, 0, 0, 167, 8, 54, 55, 56, 57, 58,
184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
194, 195, 71, 72, 196, 197, 75, 76, 77, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 198, 0, 0, 0, 0, 0,
0, 161, 79, 0, 0, 0, 162, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 199, 0, 0,
0, 0, 0, 0, 0, 0, 0, 163, 164, 200,
201, 0, 0, 0, 84, 0, 0, 0, 0, 165,
0, 0, 0, 334, 0, 0, 0, 167, 8, 54,
55, 56, 57, 58, 184, 185, 186, 187, 188, 189,
190, 191, 192, 193, 194, 195, 71, 72, 196, 197,
75, 76, 77, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 198, 0,
0, 0, 0, 0, 0, 161, 79, 0, 0, 0,
162, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 199, 0, 0, 0, 0, 0, 0, 0, 0,
0, 163, 164, 200, 201, 0, 0, 0, 84, 0,
0, 0, 0, 165, 0, 0, 8, 343, 0, 0,
0, 167, 59, 60, 61, 62, 63, 64, 65, 66,
67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
77, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 78, 0, 0, 0,
0, 0, 0, 161, 79, 0, 0, 0, 162, 0,
0, 0, 0, 0, 80, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 81,
0, 0, 0, 0, 0, 0, 0, 0, 0, 163,
164, 82, 83, 0, 0, 0, 0, 0, 0, 0,
0, 217, 0, 0, 0, 218, 0, 0, 0, 167,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 0, 0, 0, 0, 79, 0,
0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 82, 83, 0, 0, 0,
84, 0, 0, 0, 0, 0, 405, 8, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
76, 77, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 78, 0, 0,
0, 0, 0, 0, 0, 79, 0, 0, 0, 0,
0, 0, 0, 0, 0, 80, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 82, 83, 0, 0, 0, 84, 0, 0,
0, 0, 0, 475, 8, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 70, 71, 72, 73, 74, 75, 76, 77, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 78, 0, 0, 0, 0, 0,
0, 0, 79, 0, 0, 0, 0, 0, 0, 0,
0, 0, 80, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 81, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 82,
83, 0, 0, 0, 84, 0, 0, 0, 0, 555,
8, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 527, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
78, 0, 0, 0, 0, 0, 0, 0, 79, 0,
0, 0, 0, 0, 0, 0, 0, 0, 80, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 81, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 82, 83, 0, 0, 0,
84, 8, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 78, 0, 0, 0, 0, 0, 0, 0, 79,
0, 0, 0, 0, 0, 0, 0, 0, 0, 80,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 81, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 82, 83, 0, 0,
0, 84, 8, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 408, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 78, 0, 0, 0, 0, 0, 0, 0,
79, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 81, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 82, 83, 0,
0, 0, 84, 8, 54, 55, 56, 57, 58, 184,
185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
195, 71, 72, 196, 197, 75, 76, 77, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 198, 0, 0, 0, 0, 0, 0,
0, 79, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 199, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 200, 201,
0, 0, 0, 84
};
static const yytype_int16 yycheck[] =
{
0, 0, 16, 154, 285, 5, 6, 7, 105, 117,
17, 169, 165, 3, 14, 367, 16, 30, 172, 17,
235, 179, 219, 3, 132, 311, 301, 3, 309, 226,
85, 3, 367, 396, 70, 49, 9, 51, 28, 12,
3, 537, 362, 98, 77, 153, 49, 691, 28, 49,
105, 51, 28, 70, 71, 3, 3, 16, 421, 92,
12, 13, 3, 129, 97, 70, 99, 598, 129, 13,
129, 434, 328, 329, 128, 124, 332, 143, 70, 230,
129, 28, 10, 71, 145, 13, 100, 302, 147, 733,
49, 97, 146, 99, 309, 70, 97, 100, 99, 75,
100, 70, 71, 423, 80, 119, 132, 133, 123, 202,
165, 147, 167, 71, 169, 71, 131, 117, 117, 119,
213, 134, 135, 136, 278, 656, 85, 98, 624, 5,
147, 140, 132, 132, 409, 111, 112, 295, 152, 98,
113, 100, 147, 3, 142, 298, 105, 202, 71, 182,
502, 503, 152, 153, 153, 147, 146, 354, 213, 147,
123, 524, 217, 146, 219, 318, 146, 502, 131, 202,
146, 457, 147, 459, 146, 123, 462, 80, 147, 127,
213, 154, 123, 131, 130, 113, 138, 139, 285, 147,
553, 147, 165, 390, 165, 129, 202, 16, 561, 396,
415, 202, 355, 16, 460, 461, 123, 213, 111, 112,
127, 145, 213, 147, 227, 75, 216, 216, 499, 141,
80, 228, 166, 129, 147, 3, 154, 80, 3, 383,
285, 202, 146, 70, 71, 128, 49, 292, 166, 145,
129, 144, 213, 128, 217, 46, 47, 80, 303, 129,
28, 111, 112, 146, 309, 310, 145, 230, 111, 112,
612, 146, 518, 123, 520, 145, 3, 211, 46, 377,
243, 131, 85, 123, 218, 76, 235, 431, 111, 112,
129, 562, 0, 211, 97, 98, 99, 100, 124, 303,
218, 28, 105, 3, 580, 581, 145, 75, 76, 126,
75, 3, 230, 303, 85, 80, 129, 124, 363, 46,
147, 3, 409, 10, 11, 243, 97, 98, 99, 70,
71, 146, 145, 129, 147, 298, 285, 524, 146, 302,
131, 304, 618, 619, 389, 390, 111, 112, 75, 76,
143, 147, 301, 146, 124, 318, 124, 124, 123, 129,
309, 129, 129, 3, 409, 299, 131, 7, 8, 9,
80, 3, 417, 418, 419, 75, 123, 367, 143, 424,
80, 299, 28, 428, 123, 408, 123, 377, 377, 129,
661, 414, 355, 75, 14, 15, 28, 124, 80, 202,
334, 111, 112, 123, 367, 145, 147, 127, 342, 343,
213, 111, 112, 417, 131, 127, 334, 123, 559, 136,
137, 127, 356, 123, 342, 343, 389, 417, 27, 111,
112, 202, 235, 146, 144, 124, 399, 146, 356, 123,
129, 123, 213, 75, 362, 127, 3, 381, 80, 3,
124, 369, 3, 80, 499, 129, 7, 8, 9, 127,
409, 379, 124, 381, 235, 3, 415, 129, 417, 7,
8, 9, 124, 422, 28, 146, 124, 129, 77, 111,
112, 129, 285, 123, 111, 112, 126, 127, 124, 493,
124, 425, 46, 92, 147, 129, 145, 146, 488, 141,
142, 143, 144, 493, 144, 423, 309, 425, 442, 128,
129, 124, 502, 503, 285, 114, 143, 562, 75, 118,
124, 75, 76, 80, 442, 123, 147, 550, 124, 127,
301, 465, 123, 131, 129, 469, 137, 138, 309, 502,
503, 128, 139, 140, 146, 145, 146, 465, 127, 483,
499, 469, 281, 282, 111, 112, 145, 145, 157, 128,
146, 127, 124, 124, 128, 483, 123, 124, 124, 147,
147, 124, 123, 128, 131, 126, 127, 124, 146, 146,
124, 180, 516, 182, 124, 123, 128, 16, 126, 127,
594, 595, 596, 144, 46, 47, 559, 128, 516, 128,
128, 123, 143, 593, 594, 595, 596, 123, 598, 123,
123, 145, 415, 145, 417, 605, 661, 147, 622, 422,
49, 145, 612, 75, 76, 124, 123, 146, 80, 124,
564, 146, 622, 143, 233, 146, 235, 128, 409, 128,
128, 559, 58, 145, 415, 124, 564, 147, 144, 612,
144, 422, 123, 146, 146, 145, 85, 143, 648, 111,
112, 146, 652, 66, 147, 655, 656, 147, 97, 98,
99, 100, 488, 663, 663, 145, 105, 149, 147, 131,
147, 685, 281, 282, 688, 147, 285, 503, 147, 147,
147, 681, 682, 147, 684, 685, 499, 687, 688, 148,
150, 691, 691, 302, 303, 151, 42, 99, 278, 308,
309, 310, 311, 439, 661, 562, 399, 384, 502, 318,
243, 320, 712, 243, 369, 659, 243, -1, 499, 328,
329, -1, -1, 332, -1, -1, -1, -1, -1, 729,
-1, 659, 732, 733, 733, 679, -1, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, -1, -1, -1,
-1, 679, -1, -1, 363, -1, -1, -1, 367, -1,
-1, -1, -1, 202, -1, -1, -1, 593, -1, -1,
-1, -1, -1, -1, 213, 384, -1, -1, -1, 605,
389, 390, -1, -1, -1, -1, 612, 396, -1, -1,
-1, 9, -1, -1, 12, -1, 235, -1, 16, 408,
409, -1, -1, -1, -1, 414, 415, -1, 417, -1,
419, -1, 421, -1, -1, 424, -1, -1, -1, 428,
-1, 113, 648, -1, -1, 434, 652, 436, -1, 655,
-1, 49, -1, -1, -1, -1, -1, -1, 447, -1,
-1, -1, -1, -1, -1, -1, 285, -1, 457, -1,
459, 460, 461, 462, -1, 681, 682, -1, 684, -1,
-1, 687, 154, 144, -1, -1, -1, 85, -1, -1,
309, -1, -1, -1, -1, 180, -1, -1, -1, 488,
98, 490, 100, -1, -1, 494, 712, 105, 180, -1,
499, -1, -1, 502, 503, 113, -1, -1, -1, -1,
-1, 85, 238, 729, -1, -1, 732, -1, 92, 518,
-1, 520, -1, -1, 98, 524, 525, -1, -1, -1,
-1, 105, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 154, -1, 230, 548,
-1, 550, 160, -1, 553, -1, -1, 165, -1, -1,
-1, 243, 561, 562, -1, -1, -1, 566, -1, -1,
-1, -1, 180, -1, -1, -1, 575, -1, -1, -1,
-1, 580, 581, -1, -1, -1, 415, -1, 417, -1,
-1, 165, -1, 422, 593, -1, -1, 323, 324, 325,
326, -1, -1, -1, -1, -1, 605, -1, -1, 217,
218, -1, -1, 612, -1, -1, 311, -1, -1, 618,
619, -1, 230, -1, -1, -1, -1, 235, 202, 311,
-1, -1, -1, 328, 329, 243, -1, 332, -1, 213,
-1, -1, -1, 217, -1, -1, 328, 329, -1, 648,
332, -1, -1, 652, -1, -1, 655, -1, -1, -1,
-1, -1, 661, -1, -1, -1, -1, -1, -1, -1,
499, -1, -1, -1, -1, -1, -1, 285, -1, -1,
-1, -1, 681, 682, -1, 684, -1, 369, 687, -1,
298, -1, -1, 301, 302, -1, 304, -1, -1, -1,
-1, 309, -1, 311, -1, -1, -1, -1, -1, -1,
318, 285, -1, 712, -1, 1, 16, 3, 4, 5,
328, 329, -1, -1, 332, 333, -1, -1, -1, 303,
729, -1, -1, 732, -1, 309, -1, -1, -1, -1,
-1, -1, 28, -1, -1, -1, 320, 355, 356, 49,
-1, -1, -1, -1, -1, -1, -1, 439, -1, 367,
-1, -1, 457, -1, 459, 460, 461, 462, -1, -1,
-1, -1, -1, -1, -1, 457, -1, 459, 460, 461,
462, 389, -1, -1, -1, 85, 72, 73, -1, 363,
-1, 399, -1, -1, -1, -1, -1, 97, 98, 99,
100, 409, -1, -1, -1, 105, -1, 415, -1, 417,
-1, -1, -1, -1, 422, 389, -1, 103, 104, -1,
-1, -1, 396, 518, -1, 520, -1, -1, -1, -1,
-1, -1, -1, 119, 442, 409, 518, 123, 520, 125,
414, -1, -1, 417, -1, -1, -1, 421, -1, 457,
424, 459, 460, 461, 462, -1, -1, -1, -1, -1,
434, -1, -1, -1, -1, -1, -1, 167, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 559, -1, -1,
-1, -1, -1, -1, -1, 580, 581, -1, -1, -1,
-1, 499, -1, -1, 502, 503, -1, -1, 580, 581,
626, 627, 202, -1, -1, -1, -1, -1, -1, -1,
518, -1, 520, 213, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 618, 619, 499, -1, -1, -1, 285,
-1, -1, -1, -1, -1, 235, 618, 619, -1, -1,
-1, -1, -1, 285, -1, 671, 672, 303, 674, 675,
524, 559, -1, 309, 310, -1, -1, -1, -1, -1,
-1, 303, -1, -1, 320, -1, -1, 309, -1, 695,
-1, 697, 580, 581, -1, -1, -1, 703, 704, 553,
-1, -1, -1, -1, -1, 285, -1, 561, 562, -1,
-1, -1, 292, 719, -1, 721, -1, 723, -1, 725,
-1, 301, -1, -1, 612, -1, -1, 363, -1, 309,
618, 619, -1, -1, -1, 741, -1, 743, -1, -1,
-1, 363, 1, -1, 3, 4, 5, 6, -1, 8,
9, -1, -1, 389, 390, -1, -1, -1, -1, -1,
396, -1, -1, -1, -1, -1, -1, 389, 390, 28,
-1, -1, -1, -1, 396, -1, -1, -1, -1, -1,
-1, 417, -1, 419, -1, 421, -1, -1, 424, -1,
-1, -1, 428, -1, -1, 417, -1, 419, 434, 421,
436, -1, 424, -1, -1, -1, 428, 661, -1, -1,
-1, 447, 434, 72, 73, 74, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 409,
-1, -1, -1, -1, -1, 415, -1, 417, 418, -1,
-1, -1, 422, -1, 103, 104, -1, -1, -1, -1,
-1, 110, -1, -1, -1, -1, -1, -1, -1, -1,
119, -1, -1, 499, 123, 124, 125, -1, -1, -1,
-1, 130, 131, 132, 133, 134, 135, 499, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 146, 524, 525,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 524, 525, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 553, -1, 499,
-1, -1, -1, -1, -1, 561, 562, -1, -1, -1,
566, 553, -1, -1, -1, -1, -1, -1, -1, 561,
562, -1, -1, 1, 566, 3, 4, 5, 6, -1,
8, 9, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, -1, -1, -1,
68, -1, -1, -1, 72, 73, 74, -1, 76, -1,
78, -1, -1, -1, -1, 661, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 661,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, 110, -1, -1, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, -1, -1,
-1, -1, 130, 131, 132, 133, 134, 135, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, 146, 147,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-1, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, -1, -1, -1, 68, -1, -1, -1, 72,
73, 74, -1, 76, -1, 78, -1, -1, -1, -1,
-1, -1, -1, 86, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
113, 114, -1, -1, -1, 118, 119, -1, -1, -1,
123, -1, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, 1, -1, 3, 4, 5, 6, -1,
8, 9, 145, 146, 147, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, -1, -1, -1,
68, -1, -1, -1, 72, 73, 74, -1, 76, -1,
78, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, 110, -1, -1, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, -1, -1,
-1, -1, 130, 131, 132, 133, 134, 135, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, 146, 147,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 68, -1, -1, -1, 72,
73, 74, -1, 76, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 86, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
113, 114, -1, -1, -1, 118, 119, -1, -1, -1,
123, -1, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, 1, -1, 3, 4, 5, 6, -1,
8, 9, 145, 146, 147, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, 72, 73, 74, -1, 76, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, 110, -1, -1, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, -1, -1,
-1, -1, 130, 131, 132, 133, 134, 135, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, 146, 147,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 68, -1, -1, -1, 72,
73, 74, -1, 76, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 86, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
113, 114, -1, -1, -1, 118, 119, -1, -1, -1,
123, -1, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, 1, -1, 3, 4, 5, 6, -1,
8, 9, 145, 146, 147, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, 72, 73, 74, -1, 76, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, 110, -1, -1, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, -1, -1,
-1, -1, 130, 131, 132, 133, 134, 135, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, 146, 147,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 68, -1, -1, -1, 72,
73, 74, -1, 76, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 86, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
113, 114, -1, -1, -1, 118, 119, -1, -1, -1,
123, 1, 125, 3, 4, 5, -1, 130, 131, 132,
133, 134, 135, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 145, 146, 147, -1, -1, -1, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
-1, -1, 72, 73, -1, 75, 76, -1, -1, 79,
80, -1, -1, -1, -1, -1, 86, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 101, -1, 103, 104, -1, -1, -1, -1, -1,
-1, 111, 112, 113, 114, -1, -1, -1, 118, 119,
-1, -1, -1, 123, 1, 125, 3, 4, 5, -1,
-1, 131, -1, -1, 134, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 145, -1, 147, -1, -1,
-1, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 68, 69, -1, -1, 72, 73, -1, 75, 76,
-1, -1, 79, 80, -1, -1, -1, -1, -1, 86,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 101, -1, 103, 104, -1, -1,
-1, -1, -1, -1, 111, 112, 113, 114, -1, -1,
-1, 118, 119, -1, -1, -1, 123, 1, 125, 3,
4, 5, -1, -1, 131, -1, -1, 134, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 145, -1,
147, -1, -1, -1, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 68, 69, -1, -1, 72, 73,
-1, 75, 76, -1, -1, 79, 80, -1, -1, -1,
-1, -1, 86, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 101, -1, 103,
104, -1, -1, -1, -1, -1, -1, 111, 112, 113,
114, -1, -1, -1, 118, 119, -1, -1, -1, 123,
1, 125, 3, 4, 5, -1, -1, 131, -1, -1,
134, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 145, -1, 147, -1, -1, -1, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 68, 69, -1,
-1, 72, 73, -1, 75, 76, -1, -1, 79, 80,
-1, -1, -1, -1, -1, 86, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
101, -1, 103, 104, -1, -1, -1, -1, -1, -1,
111, 112, 113, 114, -1, -1, -1, 118, 119, -1,
-1, -1, 123, 1, 125, 3, 4, 5, -1, -1,
131, -1, -1, 134, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 145, -1, 147, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, 69, -1, -1, 72, 73, -1, 75, 76, -1,
-1, 79, 80, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, -1, 111, 112, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, 1, 125, 3, 4,
5, -1, -1, 131, -1, -1, 134, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 145, -1, 147,
-1, -1, -1, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 68, 69, -1, -1, 72, 73, -1,
75, 76, -1, -1, 79, 80, -1, -1, -1, -1,
-1, 86, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 101, -1, 103, 104,
-1, -1, -1, -1, -1, -1, 111, 112, 113, 114,
-1, -1, -1, 118, 119, -1, -1, -1, 123, 1,
125, 3, 4, 5, -1, -1, 131, -1, -1, 134,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
145, -1, 147, -1, -1, -1, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 68, 69, -1, -1,
72, 73, -1, 75, 76, -1, -1, 79, 80, -1,
-1, -1, -1, -1, 86, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 101,
-1, 103, 104, -1, -1, -1, -1, -1, -1, 111,
112, 113, 114, -1, -1, -1, 118, 119, -1, -1,
-1, 123, 1, 125, 3, 4, 5, -1, -1, 131,
-1, -1, 134, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 145, -1, 147, -1, -1, -1, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
69, -1, -1, 72, 73, -1, 75, 76, -1, -1,
79, 80, -1, -1, -1, -1, -1, 86, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 101, -1, 103, 104, -1, -1, -1, -1,
-1, -1, 111, 112, 113, 114, -1, -1, -1, 118,
119, -1, -1, -1, 123, 1, 125, 3, 4, 5,
-1, -1, 131, -1, -1, 134, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 145, -1, 147, -1,
-1, -1, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 68, 69, -1, -1, 72, 73, -1, 75,
76, -1, -1, 79, 80, -1, -1, -1, -1, -1,
86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 101, -1, 103, 104, -1,
-1, -1, -1, -1, -1, 111, 112, 113, 114, -1,
-1, -1, 118, 119, -1, -1, -1, 123, 1, 125,
3, 4, 5, -1, -1, 131, -1, -1, 134, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 145,
-1, 147, -1, -1, -1, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 68, 69, -1, -1, 72,
73, -1, 75, 76, -1, -1, 79, 80, -1, -1,
-1, -1, -1, 86, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 101, -1,
103, 104, -1, -1, -1, -1, -1, -1, 111, 112,
113, 114, -1, -1, -1, 118, 119, -1, -1, -1,
123, 1, 125, 3, 4, 5, -1, -1, 131, -1,
-1, 134, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 145, -1, 147, -1, -1, -1, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
-1, -1, 72, 73, -1, 75, 76, -1, -1, 79,
80, -1, -1, -1, -1, -1, 86, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 101, -1, 103, 104, -1, -1, -1, -1, -1,
-1, 111, 112, 113, 114, -1, -1, -1, 118, 119,
-1, -1, -1, 123, 1, 125, 3, 4, 5, -1,
-1, 131, -1, -1, 134, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 145, -1, 147, -1, -1,
-1, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, -1, -1, 1, -1,
3, 4, 5, 6, -1, 8, 9, -1, -1, -1,
-1, 68, 69, -1, -1, 72, 73, -1, 75, 76,
-1, -1, 79, 80, -1, 28, -1, -1, -1, 86,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 101, -1, 103, 104, -1, -1,
-1, -1, -1, -1, 111, 112, 113, 114, -1, -1,
-1, 118, 119, -1, -1, -1, 123, -1, 125, 72,
73, 74, -1, -1, 131, -1, -1, 134, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 145, -1,
147, -1, -1, -1, -1, -1, -1, -1, -1, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
-1, -1, -1, -1, -1, -1, 119, -1, -1, -1,
123, -1, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, 1, -1, 3, 4, 5, 6, -1,
8, 9, -1, 146, 147, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, -1, -1, -1,
68, -1, -1, -1, 72, 73, 74, -1, 76, -1,
78, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, 110, -1, -1, 113, 114, -1, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, -1, -1,
-1, -1, 130, 131, 132, 133, 134, 135, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, 146, -1,
-1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
6, -1, 8, 9, -1, 28, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 28, -1, -1, -1, -1, -1, -1, -1,
-1, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, -1, -1, -1, -1, -1, -1, -1, 72,
73, 74, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 72, 73, 74, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
-1, -1, -1, -1, -1, -1, 119, 103, 104, -1,
123, -1, 125, -1, 110, -1, -1, 130, 131, 132,
133, 134, 135, 119, -1, -1, -1, 123, -1, 125,
-1, -1, 145, 146, 130, 131, 132, 133, 134, 135,
1, -1, 3, 4, 5, 6, -1, 8, 9, -1,
146, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 28, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 72, 73, 74, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 103, 104, -1, -1, -1, -1, -1, 110,
-1, -1, -1, -1, -1, -1, -1, -1, 119, -1,
-1, -1, 123, 1, 125, 3, 4, 5, -1, 130,
131, 132, 133, 134, 135, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 146, -1, -1, -1, -1,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, 1, -1, 3,
4, 5, 6, -1, 8, 9, -1, -1, -1, -1,
68, 69, -1, -1, 72, 73, -1, 75, 76, -1,
-1, 79, 80, -1, 28, -1, -1, -1, 86, -1,
1, -1, 3, 4, 5, 6, -1, 8, 9, -1,
-1, -1, -1, 101, -1, 103, 104, -1, -1, -1,
-1, -1, -1, 111, 112, 113, 114, 28, -1, -1,
118, 119, -1, -1, -1, 123, -1, 125, 72, 73,
74, -1, -1, 131, -1, -1, 134, -1, 1, -1,
3, 4, 5, 6, -1, 8, 9, 145, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 103,
104, 72, 73, 74, -1, 28, 110, -1, -1, -1,
-1, -1, -1, -1, -1, 119, -1, -1, -1, 123,
124, 125, -1, -1, -1, -1, 130, 131, 132, 133,
134, 135, 103, 104, -1, -1, -1, -1, -1, 110,
-1, 145, -1, -1, -1, -1, -1, -1, 119, 72,
73, 74, 123, 124, 125, -1, -1, -1, -1, 130,
131, 132, 133, 134, 135, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 145, -1, -1, -1, -1, -1,
103, 104, -1, -1, -1, -1, -1, 110, -1, -1,
-1, -1, -1, -1, -1, -1, 119, -1, 3, -1,
123, -1, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 145, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 68, -1, -1, -1, -1, -1, -1,
75, 76, -1, -1, -1, 80, -1, -1, -1, -1,
-1, 86, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 111, 112, 113, 114,
-1, -1, -1, 118, -1, -1, -1, 3, 123, -1,
-1, -1, 127, -1, -1, -1, 131, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 146, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 68, -1, -1, -1, -1, -1, -1, 75,
76, -1, -1, -1, 80, -1, -1, -1, -1, -1,
86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 111, 112, 113, 114, -1,
-1, -1, 118, -1, -1, 3, -1, 123, -1, -1,
-1, -1, -1, -1, -1, 131, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 143, -1, 145,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, -1, -1, -1, 75, 76, -1,
-1, -1, 80, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 111, 112, 113, 114, -1, -1, 1,
118, 3, 4, 5, 6, 123, 8, 9, -1, -1,
-1, -1, -1, 131, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 28, 145, -1, -1,
-1, -1, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 68, -1, -1, -1,
72, 73, 74, 75, 76, -1, -1, -1, 80, -1,
-1, -1, -1, -1, 86, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 101,
-1, 103, 104, -1, -1, -1, -1, -1, 110, 111,
112, 113, 114, -1, -1, -1, -1, 119, -1, -1,
-1, 123, 124, 125, -1, -1, -1, -1, 130, 131,
132, 133, 134, 135, 1, -1, 3, 4, 5, 6,
-1, 8, 9, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 28, -1, -1, -1, -1, -1, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 68, -1, -1, -1, 72, 73, 74, 1, 76,
3, 4, 5, 6, -1, 8, 9, -1, -1, 86,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 101, 28, 103, 104, -1, -1,
-1, -1, -1, 110, -1, -1, 113, 114, -1, -1,
-1, -1, 119, -1, -1, -1, 123, 124, 125, -1,
-1, -1, -1, 130, 131, 132, 133, 134, 135, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 72,
73, 74, 75, -1, -1, -1, 1, 80, 3, 4,
5, 6, -1, 8, 9, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
103, 104, -1, 28, -1, -1, -1, 110, 111, 112,
1, -1, 3, 4, 5, 6, 119, 8, 9, -1,
123, 124, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, -1, -1, -1, -1, 28, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 72, 73, 74,
1, -1, 3, 4, 5, 6, -1, 8, 9, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 28, 103, 104,
-1, 72, 73, 74, 1, 110, 3, 4, 5, 6,
-1, 8, 9, -1, 119, -1, -1, -1, 123, 124,
125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
135, 28, 103, 104, -1, -1, -1, -1, -1, 110,
-1, 72, 73, 74, -1, -1, -1, -1, 119, -1,
-1, -1, 123, -1, 125, -1, -1, 128, -1, 130,
131, 132, 133, 134, 135, -1, -1, -1, -1, -1,
-1, -1, 103, 104, -1, 72, 73, 74, 1, 110,
3, 4, 5, 6, -1, 8, 9, -1, 119, -1,
-1, -1, 123, -1, 125, -1, -1, 128, -1, 130,
131, 132, 133, 134, 135, 28, 103, 104, -1, -1,
-1, -1, 1, 110, 3, 4, 5, 6, -1, 8,
9, -1, 119, -1, -1, -1, 123, -1, 125, -1,
-1, 128, -1, 130, 131, 132, 133, 134, 135, 28,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 72,
73, 74, 1, -1, 3, 4, 5, 6, -1, 8,
9, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 28,
103, 104, -1, 72, 73, 74, 1, 110, 3, 4,
5, 6, -1, 8, 9, -1, 119, -1, -1, -1,
123, 124, 125, -1, -1, -1, -1, 130, 131, 132,
133, 134, 135, 28, 103, 104, -1, -1, -1, -1,
-1, 110, -1, 72, 73, 74, -1, -1, -1, -1,
119, -1, -1, -1, 123, 124, 125, -1, -1, -1,
-1, 130, 131, 132, 133, 134, 135, -1, -1, -1,
-1, -1, -1, -1, 103, 104, -1, 72, 73, 74,
1, 110, 3, 4, 5, 6, -1, 8, 9, -1,
119, -1, -1, -1, 123, -1, 125, -1, -1, -1,
-1, 130, 131, 132, 133, 134, 135, 28, 103, 104,
-1, -1, -1, -1, 1, 110, 3, 4, 5, 6,
-1, 8, 9, -1, 119, -1, -1, -1, 123, -1,
125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
135, 28, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 72, 73, 74, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 103, 104, -1, 72, 73, 74, -1, 110,
-1, -1, -1, -1, -1, -1, -1, -1, 119, -1,
-1, -1, 123, -1, 125, -1, -1, -1, -1, 130,
131, 132, 133, 134, 135, -1, 103, 104, -1, -1,
-1, -1, -1, 110, 3, -1, -1, -1, -1, -1,
-1, -1, 119, -1, -1, -1, 123, -1, 125, -1,
-1, -1, -1, 130, 131, 132, 133, 134, 135, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
49, 50, 51, 52, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
-1, -1, -1, -1, -1, -1, 75, 76, -1, -1,
-1, 80, -1, -1, -1, -1, -1, 86, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 101, -1, -1, -1, -1, -1, 3, -1,
-1, -1, 111, 112, 113, 114, -1, -1, -1, 118,
-1, -1, -1, -1, 123, 124, -1, -1, 127, -1,
-1, -1, 131, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 68, -1, -1, -1, -1, -1, -1,
75, 76, -1, -1, -1, 80, -1, -1, -1, -1,
-1, 86, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
-1, -1, 3, -1, -1, -1, 111, 112, 113, 114,
-1, -1, -1, 118, -1, -1, -1, -1, 123, -1,
-1, -1, 127, -1, -1, -1, 131, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 68, -1, -1,
-1, -1, -1, -1, 75, 76, -1, -1, -1, 80,
-1, -1, -1, -1, -1, 86, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
101, -1, -1, -1, -1, -1, 3, -1, -1, -1,
111, 112, 113, 114, -1, -1, -1, 118, -1, -1,
-1, -1, 123, -1, -1, -1, -1, -1, -1, -1,
131, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 68, -1, -1, -1, -1, -1, -1, -1, 76,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 113, 114, -1, -1,
-1, 118, -1, -1, -1, -1, -1, 124, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 68, -1,
-1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
80, -1, -1, -1, -1, -1, 86, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 101, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 111, 112, 113, 114, -1, -1, -1, 118, -1,
-1, -1, -1, 123, 124, -1, -1, 127, -1, -1,
-1, 131, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 68, -1, -1, -1, -1, -1, -1, 75,
76, -1, -1, -1, 80, -1, -1, -1, -1, -1,
86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 111, 112, 113, 114, -1,
-1, -1, 118, -1, -1, -1, -1, 123, -1, -1,
-1, 127, -1, -1, -1, 131, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 68, -1, -1, -1,
-1, -1, -1, 75, 76, -1, -1, -1, 80, -1,
-1, -1, -1, -1, 86, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 101,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 111,
112, 113, 114, -1, -1, -1, 118, -1, -1, -1,
-1, 123, -1, -1, -1, 127, -1, -1, -1, 131,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, -1, -1, -1, 75, 76, -1,
-1, -1, 80, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 111, 112, 113, 114, -1, -1, -1,
118, -1, -1, -1, -1, 123, 124, -1, -1, -1,
-1, -1, -1, 131, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 68, -1, -1, -1, -1, -1,
-1, 75, 76, -1, -1, -1, 80, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 111, 112, 113,
114, -1, -1, -1, 118, -1, -1, -1, -1, 123,
-1, -1, -1, 127, -1, -1, -1, 131, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 68, -1,
-1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
80, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 101, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 111, 112, 113, 114, -1, -1, -1, 118, -1,
-1, -1, -1, 123, -1, -1, 28, 127, -1, -1,
-1, 131, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 68, -1, -1, -1,
-1, -1, -1, 75, 76, -1, -1, -1, 80, -1,
-1, -1, -1, -1, 86, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 101,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 111,
112, 113, 114, -1, -1, -1, -1, -1, -1, -1,
-1, 123, -1, -1, -1, 127, -1, -1, -1, 131,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, -1, -1, -1, -1, 76, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 113, 114, -1, -1, -1,
118, -1, -1, -1, -1, -1, 124, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 68, -1, -1,
-1, -1, -1, -1, -1, 76, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 86, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
101, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 113, 114, -1, -1, -1, 118, -1, -1,
-1, -1, -1, 124, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 68, -1, -1, -1, -1, -1,
-1, -1, 76, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 86, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 113,
114, -1, -1, -1, 118, -1, -1, -1, -1, 123,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
68, -1, -1, -1, -1, -1, -1, -1, 76, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 113, 114, -1, -1, -1,
118, 28, 29, 30, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 68, -1, -1, -1, -1, -1, -1, -1, 76,
-1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 101, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 113, 114, -1, -1,
-1, 118, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, 113, 114, -1,
-1, -1, 118, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 68, -1, -1, -1, -1, -1, -1,
-1, 76, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 101, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 113, 114,
-1, -1, -1, 118
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =
{
0, 1, 3, 4, 5, 6, 8, 9, 28, 72,
73, 74, 103, 104, 110, 119, 123, 125, 130, 131,
132, 133, 134, 135, 149, 150, 151, 153, 155, 156,
157, 158, 159, 160, 161, 162, 163, 164, 165, 166,
167, 168, 169, 170, 190, 191, 239, 241, 255, 123,
156, 123, 156, 156, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, 68, 76,
86, 101, 113, 114, 118, 176, 181, 189, 190, 192,
194, 195, 196, 204, 205, 156, 169, 173, 176, 173,
123, 156, 124, 170, 172, 175, 189, 190, 192, 194,
205, 224, 239, 146, 7, 8, 9, 123, 126, 127,
149, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 144, 171, 158, 131, 136, 137, 132, 133, 10,
11, 12, 13, 138, 139, 14, 15, 130, 140, 141,
16, 17, 142, 171, 146, 0, 224, 146, 149, 191,
123, 75, 80, 111, 112, 123, 127, 131, 181, 182,
183, 187, 188, 189, 192, 194, 205, 209, 211, 219,
146, 149, 182, 191, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 48, 49, 68, 101,
113, 114, 178, 181, 189, 191, 193, 194, 195, 204,
205, 127, 211, 178, 224, 124, 129, 123, 127, 182,
189, 192, 194, 205, 208, 210, 219, 124, 126, 145,
146, 147, 152, 153, 169, 176, 226, 242, 248, 249,
250, 251, 252, 253, 254, 149, 124, 152, 154, 170,
149, 172, 152, 170, 158, 158, 158, 159, 159, 160,
160, 161, 161, 161, 161, 162, 162, 163, 164, 165,
166, 167, 172, 152, 170, 147, 254, 124, 149, 206,
207, 146, 146, 190, 124, 176, 211, 220, 221, 222,
173, 189, 218, 219, 209, 219, 123, 187, 123, 127,
209, 69, 79, 123, 134, 145, 147, 149, 153, 176,
182, 197, 198, 199, 200, 201, 213, 214, 216, 217,
219, 240, 241, 243, 244, 245, 246, 247, 146, 146,
149, 191, 146, 123, 127, 181, 189, 193, 194, 205,
211, 173, 127, 127, 211, 124, 170, 124, 210, 220,
128, 173, 190, 208, 219, 123, 127, 208, 158, 239,
147, 254, 144, 123, 149, 214, 146, 233, 234, 129,
145, 145, 249, 251, 252, 147, 124, 129, 128, 143,
147, 144, 187, 188, 129, 147, 206, 206, 124, 123,
182, 210, 212, 213, 215, 217, 219, 124, 124, 129,
128, 189, 219, 209, 123, 124, 220, 173, 52, 177,
181, 189, 190, 192, 196, 176, 214, 123, 131, 182,
212, 219, 176, 144, 123, 143, 145, 149, 182, 202,
203, 212, 214, 217, 219, 217, 219, 147, 201, 129,
145, 123, 127, 124, 149, 220, 223, 182, 217, 145,
145, 234, 234, 234, 145, 234, 147, 197, 147, 197,
146, 146, 197, 190, 173, 127, 128, 173, 173, 127,
124, 124, 128, 128, 208, 124, 220, 128, 173, 190,
147, 226, 147, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 78, 145, 149, 172, 174, 176,
228, 229, 230, 231, 232, 234, 235, 236, 237, 238,
240, 250, 152, 170, 169, 173, 144, 207, 145, 147,
145, 147, 213, 217, 219, 182, 215, 53, 222, 3,
28, 46, 75, 76, 124, 184, 185, 186, 124, 128,
149, 191, 146, 149, 181, 189, 190, 192, 210, 149,
182, 191, 214, 219, 124, 123, 226, 124, 173, 146,
217, 219, 129, 145, 143, 187, 182, 217, 217, 198,
128, 173, 190, 124, 124, 129, 217, 147, 147, 147,
197, 197, 147, 124, 128, 173, 128, 128, 173, 124,
128, 128, 173, 143, 123, 123, 123, 228, 123, 149,
145, 145, 145, 172, 149, 143, 145, 145, 179, 180,
212, 174, 231, 174, 228, 147, 145, 173, 197, 197,
215, 124, 123, 124, 129, 185, 70, 71, 147, 146,
146, 149, 149, 191, 124, 147, 254, 217, 203, 173,
217, 128, 128, 149, 147, 147, 128, 128, 143, 228,
172, 172, 124, 172, 58, 124, 235, 145, 145, 144,
228, 129, 145, 144, 147, 147, 172, 124, 185, 234,
234, 70, 71, 147, 70, 71, 147, 146, 147, 143,
228, 124, 124, 228, 124, 123, 228, 124, 235, 173,
180, 146, 170, 225, 124, 71, 147, 70, 147, 234,
234, 234, 234, 70, 71, 147, 173, 228, 228, 228,
172, 228, 124, 172, 145, 225, 227, 234, 234, 71,
147, 70, 147, 71, 147, 70, 147, 234, 234, 66,
124, 228, 124, 129, 147, 147, 147, 234, 234, 234,
234, 71, 147, 70, 147, 228, 145, 228, 147, 225,
147, 147, 147, 147, 234, 234, 147, 147
};
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1[] =
{
0, 148, 149, 150, 150, 151, 151, 151, 151, 151,
151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
151, 151, 152, 153, 153, 153, 153, 153, 153, 153,
153, 153, 154, 154, 154, 154, 155, 155, 155, 155,
155, 155, 155, 156, 156, 157, 157, 157, 157, 157,
157, 157, 158, 158, 159, 159, 159, 159, 160, 160,
160, 161, 161, 161, 162, 162, 162, 162, 162, 163,
163, 163, 164, 164, 165, 165, 166, 166, 167, 167,
168, 168, 169, 169, 170, 170, 170, 170, 170, 171,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
172, 172, 173, 174, 174, 174, 174, 175, 175, 175,
175, 175, 175, 175, 175, 176, 176, 176, 176, 176,
176, 176, 176, 176, 176, 177, 177, 177, 177, 177,
177, 177, 177, 178, 178, 178, 178, 178, 178, 178,
178, 178, 178, 179, 179, 180, 180, 181, 181, 181,
181, 181, 181, 182, 182, 182, 183, 183, 183, 184,
184, 184, 184, 184, 185, 185, 186, 186, 186, 187,
187, 188, 188, 189, 189, 189, 190, 191, 192, 192,
192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
193, 194, 194, 194, 194, 194, 194, 194, 194, 194,
194, 195, 195, 195, 195, 196, 196, 197, 197, 198,
199, 199, 200, 200, 200, 200, 200, 200, 200, 200,
200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
200, 200, 201, 201, 201, 201, 201, 201, 201, 201,
202, 202, 203, 203, 203, 203, 203, 204, 204, 205,
205, 205, 205, 205, 206, 206, 207, 207, 207, 207,
208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
208, 209, 209, 209, 209, 209, 210, 210, 210, 210,
210, 210, 211, 211, 211, 211, 211, 211, 212, 212,
212, 213, 213, 213, 213, 213, 214, 214, 214, 214,
214, 215, 215, 215, 215, 216, 217, 217, 217, 218,
218, 219, 219, 219, 219, 220, 220, 221, 221, 222,
222, 222, 223, 223, 224, 224, 225, 225, 225, 226,
226, 227, 227, 228, 228, 228, 228, 228, 228, 229,
229, 229, 230, 230, 231, 231, 231, 232, 232, 232,
233, 234, 234, 235, 235, 236, 236, 236, 237, 237,
237, 237, 237, 237, 237, 238, 238, 238, 238, 238,
239, 240, 240, 241, 241, 241, 241, 242, 242, 243,
243, 244, 245, 246, 246, 247, 247, 247, 247, 247,
248, 249, 250, 250, 251, 251, 252, 253, 253, 253,
253, 253, 253, 254, 254, 254, 255
};
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 1, 3, 1, 1, 1, 1, 1,
2, 4, 2, 6, 5, 6, 5, 7, 6, 7,
6, 1, 1, 1, 4, 3, 4, 3, 2, 3,
2, 2, 1, 1, 3, 3, 2, 2, 2, 2,
4, 2, 4, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 4, 1, 3, 3, 3, 1, 3,
3, 1, 3, 3, 1, 3, 3, 3, 3, 1,
3, 3, 1, 3, 1, 3, 1, 3, 1, 3,
1, 3, 1, 5, 1, 3, 3, 3, 3, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 3, 1, 2, 3, 2, 5, 1, 2, 1,
2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
2, 1, 2, 1, 2, 1, 2, 1, 2, 1,
2, 1, 2, 1, 3, 1, 3, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 4, 1, 2, 3, 6,
5, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 4, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 4,
1, 5, 4, 4, 3, 5, 6, 5, 5, 4,
6, 2, 2, 3, 3, 1, 1, 1, 2, 3,
1, 3, 9, 9, 7, 7, 5, 10, 10, 8,
8, 6, 8, 8, 6, 6, 4, 9, 9, 7,
7, 5, 3, 2, 2, 2, 1, 2, 1, 1,
1, 3, 1, 2, 2, 3, 5, 2, 2, 4,
5, 7, 7, 5, 1, 3, 1, 3, 2, 4,
3, 2, 3, 3, 3, 4, 4, 2, 3, 3,
4, 3, 2, 3, 3, 4, 1, 1, 2, 2,
2, 3, 1, 1, 2, 2, 2, 3, 1, 2,
3, 1, 3, 4, 3, 4, 1, 2, 2, 3,
3, 1, 1, 2, 2, 2, 3, 3, 2, 1,
2, 1, 2, 2, 3, 1, 3, 1, 3, 2,
2, 1, 1, 3, 1, 2, 1, 3, 4, 1,
1, 1, 3, 1, 1, 1, 1, 1, 1, 3,
4, 3, 1, 2, 1, 2, 2, 1, 1, 2,
1, 2, 3, 1, 2, 5, 7, 5, 5, 7,
6, 7, 4, 5, 4, 3, 2, 2, 2, 3,
1, 5, 4, 4, 3, 4, 3, 3, 2, 2,
1, 3, 4, 3, 2, 2, 2, 2, 2, 2,
2, 2, 3, 1, 1, 3, 2, 1, 1, 2,
2, 1, 2, 1, 1, 2, 1
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
/* Error token number */
#define YYTERROR 1
#define YYERRCODE 256
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (0)
#endif
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
/* Enable debugging if requested. */
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
/* YY_LOCATION_PRINT -- Print the location on the stream.
This macro was not mandated originally: define only if we know
we won't break user code: when these are the locations we know. */
#ifndef YY_LOCATION_PRINT
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
__attribute__((__unused__))
static unsigned
yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
{
unsigned res = 0;
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
if (0 <= yylocp->first_line)
{
res += YYFPRINTF (yyo, "%d", yylocp->first_line);
if (0 <= yylocp->first_column)
res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
}
if (0 <= yylocp->last_line)
{
if (yylocp->first_line < yylocp->last_line)
{
res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
if (0 <= end_col)
res += YYFPRINTF (yyo, ".%d", end_col);
}
else if (0 <= end_col && yylocp->first_column < end_col)
res += YYFPRINTF (yyo, "-%d", end_col);
}
return res;
}
# define YY_LOCATION_PRINT(File, Loc) \
yy_location_print_ (File, &(Loc))
# else
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value, Location); \
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
{
FILE *yyo = yyoutput;
YYUSE (yyo);
YYUSE (yylocationp);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# endif
YYUSE (yytype);
}
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
{
YYFPRINTF (yyoutput, "%s %s (",
yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
YY_LOCATION_PRINT (yyoutput, *yylocationp);
YYFPRINTF (yyoutput, ": ");
yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
YYFPRINTF (yyoutput, ")");
}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
static void
yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
{
unsigned long int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr,
yystos[yyssp[yyi + 1 - yynrhs]],
&(yyvsp[(yyi + 1) - (yynrhs)])
, &(yylsp[(yyi + 1) - (yynrhs)]) );
YYFPRINTF (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
#if YYERROR_VERBOSE
# ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
static YYSIZE_T
yystrlen (const char *yystr)
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
# endif
# ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
# endif
# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result
would have been. */
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
if (! yyres)
return yystrlen (yystr);
return yystpcpy (yyres, yystr) - yyres;
}
# endif
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return 2 if the
required number of bytes is too large to store. */
static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken)
{
YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULL;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
"expected"). */
int yycount = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
if (yytoken != YYEMPTY)
{
int yyn = yypact[*yyssp];
yyarg[yycount++] = yytname[yytoken];
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
yysize = yysize0;
break;
}
yyarg[yycount++] = yytname[yyx];
{
YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
if (! (yysize <= yysize1
&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
}
}
}
switch (yycount)
{
# define YYCASE_(N, S) \
case N: \
yyformat = S; \
break
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
}
{
YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
if (*yymsg_alloc < yysize)
{
*yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
return 1;
}
/* Avoid sprintf, as that infringes on the user's name space.
Don't have undefined behavior even if the translation
produced a string with the wrong number of "%s"s. */
{
char *yyp = *yymsg;
int yyi = 0;
while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
yyp += yytnamerr (yyp, yyarg[yyi++]);
yyformat += 2;
}
else
{
yyp++;
yyformat++;
}
}
return 0;
}
#endif /* YYERROR_VERBOSE */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
{
YYUSE (yyvaluep);
YYUSE (yylocationp);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
switch (yytype)
{
case 149: /* identifier */
#line 161 "expression.y" /* yacc.c:1274 */
{ FreeIdentifier(((*yyvaluep).id)); }
#line 3202 "expression.ec" /* yacc.c:1274 */
break;
case 150: /* primary_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3208 "expression.ec" /* yacc.c:1274 */
break;
case 153: /* postfix_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3214 "expression.ec" /* yacc.c:1274 */
break;
case 154: /* argument_expression_list */
#line 196 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeExpression); }
#line 3220 "expression.ec" /* yacc.c:1274 */
break;
case 156: /* unary_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3226 "expression.ec" /* yacc.c:1274 */
break;
case 158: /* cast_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3232 "expression.ec" /* yacc.c:1274 */
break;
case 159: /* multiplicative_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3238 "expression.ec" /* yacc.c:1274 */
break;
case 160: /* additive_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3244 "expression.ec" /* yacc.c:1274 */
break;
case 161: /* shift_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3250 "expression.ec" /* yacc.c:1274 */
break;
case 162: /* relational_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3256 "expression.ec" /* yacc.c:1274 */
break;
case 163: /* equality_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3262 "expression.ec" /* yacc.c:1274 */
break;
case 164: /* and_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3268 "expression.ec" /* yacc.c:1274 */
break;
case 165: /* exclusive_or_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3274 "expression.ec" /* yacc.c:1274 */
break;
case 166: /* inclusive_or_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3280 "expression.ec" /* yacc.c:1274 */
break;
case 167: /* logical_and_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3286 "expression.ec" /* yacc.c:1274 */
break;
case 168: /* logical_or_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3292 "expression.ec" /* yacc.c:1274 */
break;
case 169: /* conditional_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3298 "expression.ec" /* yacc.c:1274 */
break;
case 170: /* assignment_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3304 "expression.ec" /* yacc.c:1274 */
break;
case 172: /* expression */
#line 196 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeExpression); }
#line 3310 "expression.ec" /* yacc.c:1274 */
break;
case 173: /* constant_expression */
#line 163 "expression.y" /* yacc.c:1274 */
{ FreeExpression(((*yyvaluep).exp)); }
#line 3316 "expression.ec" /* yacc.c:1274 */
break;
case 174: /* declaration */
#line 182 "expression.y" /* yacc.c:1274 */
{ FreeDeclaration(((*yyvaluep).declaration)); }
#line 3322 "expression.ec" /* yacc.c:1274 */
break;
case 175: /* specifier_qualifier_list */
#line 198 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeSpecifier); }
#line 3328 "expression.ec" /* yacc.c:1274 */
break;
case 176: /* declaration_specifiers */
#line 198 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeSpecifier); }
#line 3334 "expression.ec" /* yacc.c:1274 */
break;
case 179: /* init_declarator_list */
#line 202 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeInitDeclarator); }
#line 3340 "expression.ec" /* yacc.c:1274 */
break;
case 180: /* init_declarator */
#line 177 "expression.y" /* yacc.c:1274 */
{ FreeInitDeclarator(((*yyvaluep).initDeclarator)); }
#line 3346 "expression.ec" /* yacc.c:1274 */
break;
case 181: /* storage_class_specifier */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3352 "expression.ec" /* yacc.c:1274 */
break;
case 182: /* ext_decl */
#line 210 "expression.y" /* yacc.c:1274 */
{ FreeExtDecl(((*yyvaluep).extDecl)); }
#line 3358 "expression.ec" /* yacc.c:1274 */
break;
case 184: /* attribute_word */
#line 193 "expression.y" /* yacc.c:1274 */
{ delete ((*yyvaluep).string); }
#line 3364 "expression.ec" /* yacc.c:1274 */
break;
case 185: /* attribute */
#line 211 "expression.y" /* yacc.c:1274 */
{ FreeAttribute(((*yyvaluep).attribute)); }
#line 3370 "expression.ec" /* yacc.c:1274 */
break;
case 186: /* attribs_list */
#line 212 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeAttribute); }
#line 3376 "expression.ec" /* yacc.c:1274 */
break;
case 187: /* attrib */
#line 209 "expression.y" /* yacc.c:1274 */
{ FreeAttrib(((*yyvaluep).attrib)); }
#line 3382 "expression.ec" /* yacc.c:1274 */
break;
case 188: /* multi_attrib */
#line 213 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeAttrib); }
#line 3388 "expression.ec" /* yacc.c:1274 */
break;
case 189: /* type_qualifier */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3394 "expression.ec" /* yacc.c:1274 */
break;
case 190: /* type */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3400 "expression.ec" /* yacc.c:1274 */
break;
case 191: /* strict_type */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3406 "expression.ec" /* yacc.c:1274 */
break;
case 192: /* type_specifier */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3412 "expression.ec" /* yacc.c:1274 */
break;
case 193: /* strict_type_specifier */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3418 "expression.ec" /* yacc.c:1274 */
break;
case 194: /* struct_or_union_specifier_compound */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3424 "expression.ec" /* yacc.c:1274 */
break;
case 195: /* struct_or_union_specifier_nocompound */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3430 "expression.ec" /* yacc.c:1274 */
break;
case 197: /* struct_declaration_list */
#line 205 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeClassDef); }
#line 3436 "expression.ec" /* yacc.c:1274 */
break;
case 198: /* default_property */
#line 186 "expression.y" /* yacc.c:1274 */
{ FreeMemberInit(((*yyvaluep).memberInit)); }
#line 3442 "expression.ec" /* yacc.c:1274 */
break;
case 199: /* default_property_list */
#line 206 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeMemberInit); }
#line 3448 "expression.ec" /* yacc.c:1274 */
break;
case 200: /* property */
#line 194 "expression.y" /* yacc.c:1274 */
{ FreeProperty(((*yyvaluep).prop)); }
#line 3454 "expression.ec" /* yacc.c:1274 */
break;
case 201: /* struct_declaration */
#line 192 "expression.y" /* yacc.c:1274 */
{ FreeClassDef(((*yyvaluep).classDef)); }
#line 3460 "expression.ec" /* yacc.c:1274 */
break;
case 202: /* struct_declarator_list */
#line 199 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeDeclarator); }
#line 3466 "expression.ec" /* yacc.c:1274 */
break;
case 203: /* struct_declarator */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3472 "expression.ec" /* yacc.c:1274 */
break;
case 204: /* enum_specifier_nocompound */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3478 "expression.ec" /* yacc.c:1274 */
break;
case 205: /* enum_specifier_compound */
#line 169 "expression.y" /* yacc.c:1274 */
{ FreeSpecifier(((*yyvaluep).specifier)); }
#line 3484 "expression.ec" /* yacc.c:1274 */
break;
case 206: /* enumerator_list */
#line 197 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeEnumerator); }
#line 3490 "expression.ec" /* yacc.c:1274 */
break;
case 207: /* enumerator */
#line 171 "expression.y" /* yacc.c:1274 */
{ FreeEnumerator(((*yyvaluep).enumerator)); }
#line 3496 "expression.ec" /* yacc.c:1274 */
break;
case 208: /* direct_abstract_declarator */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3502 "expression.ec" /* yacc.c:1274 */
break;
case 209: /* direct_abstract_declarator_noarray */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3508 "expression.ec" /* yacc.c:1274 */
break;
case 210: /* abstract_declarator */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3514 "expression.ec" /* yacc.c:1274 */
break;
case 211: /* abstract_declarator_noarray */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3520 "expression.ec" /* yacc.c:1274 */
break;
case 212: /* declarator */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3526 "expression.ec" /* yacc.c:1274 */
break;
case 213: /* direct_declarator_nofunction */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3532 "expression.ec" /* yacc.c:1274 */
break;
case 214: /* declarator_function */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3538 "expression.ec" /* yacc.c:1274 */
break;
case 215: /* direct_declarator */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3544 "expression.ec" /* yacc.c:1274 */
break;
case 216: /* direct_declarator_function_start */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3550 "expression.ec" /* yacc.c:1274 */
break;
case 217: /* direct_declarator_function */
#line 172 "expression.y" /* yacc.c:1274 */
{ FreeDeclarator(((*yyvaluep).declarator)); }
#line 3556 "expression.ec" /* yacc.c:1274 */
break;
case 218: /* type_qualifier_list */
#line 198 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeSpecifier); }
#line 3562 "expression.ec" /* yacc.c:1274 */
break;
case 219: /* pointer */
#line 162 "expression.y" /* yacc.c:1274 */
{ FreePointer(((*yyvaluep).pointer)); }
#line 3568 "expression.ec" /* yacc.c:1274 */
break;
case 220: /* parameter_type_list */
#line 203 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeTypeName); }
#line 3574 "expression.ec" /* yacc.c:1274 */
break;
case 221: /* parameter_list */
#line 203 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeTypeName); }
#line 3580 "expression.ec" /* yacc.c:1274 */
break;
case 222: /* parameter_declaration */
#line 178 "expression.y" /* yacc.c:1274 */
{ FreeTypeName(((*yyvaluep).typeName)); }
#line 3586 "expression.ec" /* yacc.c:1274 */
break;
case 223: /* identifier_list */
#line 203 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeTypeName); }
#line 3592 "expression.ec" /* yacc.c:1274 */
break;
case 224: /* type_name */
#line 178 "expression.y" /* yacc.c:1274 */
{ FreeTypeName(((*yyvaluep).typeName)); }
#line 3598 "expression.ec" /* yacc.c:1274 */
break;
case 225: /* initializer */
#line 176 "expression.y" /* yacc.c:1274 */
{ FreeInitializer(((*yyvaluep).initializer)); }
#line 3604 "expression.ec" /* yacc.c:1274 */
break;
case 226: /* initializer_condition */
#line 176 "expression.y" /* yacc.c:1274 */
{ FreeInitializer(((*yyvaluep).initializer)); }
#line 3610 "expression.ec" /* yacc.c:1274 */
break;
case 227: /* initializer_list */
#line 201 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeInitializer); }
#line 3616 "expression.ec" /* yacc.c:1274 */
break;
case 228: /* statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3622 "expression.ec" /* yacc.c:1274 */
break;
case 229: /* labeled_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3628 "expression.ec" /* yacc.c:1274 */
break;
case 230: /* declaration_list */
#line 200 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeDeclaration); }
#line 3634 "expression.ec" /* yacc.c:1274 */
break;
case 231: /* statement_list */
#line 204 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeStatement); }
#line 3640 "expression.ec" /* yacc.c:1274 */
break;
case 232: /* compound_inside */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3646 "expression.ec" /* yacc.c:1274 */
break;
case 233: /* compound_start */
#line 208 "expression.y" /* yacc.c:1274 */
{ PopContext(((*yyvaluep).context)); FreeContext(((*yyvaluep).context)); delete ((*yyvaluep).context); }
#line 3652 "expression.ec" /* yacc.c:1274 */
break;
case 234: /* compound_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3658 "expression.ec" /* yacc.c:1274 */
break;
case 235: /* expression_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3664 "expression.ec" /* yacc.c:1274 */
break;
case 236: /* selection_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3670 "expression.ec" /* yacc.c:1274 */
break;
case 237: /* iteration_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3676 "expression.ec" /* yacc.c:1274 */
break;
case 238: /* jump_statement */
#line 179 "expression.y" /* yacc.c:1274 */
{ FreeStatement(((*yyvaluep).stmt)); }
#line 3682 "expression.ec" /* yacc.c:1274 */
break;
case 239: /* string_literal */
#line 193 "expression.y" /* yacc.c:1274 */
{ delete ((*yyvaluep).string); }
#line 3688 "expression.ec" /* yacc.c:1274 */
break;
case 240: /* instantiation_named */
#line 184 "expression.y" /* yacc.c:1274 */
{ FreeInstance(((*yyvaluep).instance)); }
#line 3694 "expression.ec" /* yacc.c:1274 */
break;
case 241: /* instantiation_unnamed */
#line 184 "expression.y" /* yacc.c:1274 */
{ FreeInstance(((*yyvaluep).instance)); }
#line 3700 "expression.ec" /* yacc.c:1274 */
break;
case 243: /* class_function_definition_start */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3706 "expression.ec" /* yacc.c:1274 */
break;
case 244: /* constructor_function_definition_start */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3712 "expression.ec" /* yacc.c:1274 */
break;
case 245: /* destructor_function_definition_start */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3718 "expression.ec" /* yacc.c:1274 */
break;
case 246: /* virtual_class_function_definition_start */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3724 "expression.ec" /* yacc.c:1274 */
break;
case 247: /* class_function_definition */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3730 "expression.ec" /* yacc.c:1274 */
break;
case 248: /* instance_class_function_definition_start */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3736 "expression.ec" /* yacc.c:1274 */
break;
case 249: /* instance_class_function_definition */
#line 188 "expression.y" /* yacc.c:1274 */
{ FreeClassFunction(((*yyvaluep).classFunction)); }
#line 3742 "expression.ec" /* yacc.c:1274 */
break;
case 250: /* data_member_initialization */
#line 186 "expression.y" /* yacc.c:1274 */
{ FreeMemberInit(((*yyvaluep).memberInit)); }
#line 3748 "expression.ec" /* yacc.c:1274 */
break;
case 251: /* data_member_initialization_list */
#line 206 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeMemberInit); }
#line 3754 "expression.ec" /* yacc.c:1274 */
break;
case 252: /* data_member_initialization_list_coloned */
#line 206 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeMemberInit); }
#line 3760 "expression.ec" /* yacc.c:1274 */
break;
case 253: /* members_initialization_list_coloned */
#line 207 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeMembersInit); }
#line 3766 "expression.ec" /* yacc.c:1274 */
break;
case 254: /* members_initialization_list */
#line 207 "expression.y" /* yacc.c:1274 */
{ FreeList(((*yyvaluep).list), FreeMembersInit); }
#line 3772 "expression.ec" /* yacc.c:1274 */
break;
default:
break;
}
}
/* The lookahead symbol. */
int yychar;
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
/* The semantic value of the lookahead symbol. */
YYSTYPE yylval YY_INITIAL_VALUE (yyval_default);
/* Location data for the lookahead symbol. */
YYLTYPE yylloc
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
= { 1, 1, 1, 1 }
# endif
;
/* Number of syntax errors so far. */
int yynerrs;
/*----------.
| yyparse. |
`----------*/
int
yyparse (void)
{
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
'yyss': related to states.
'yyvs': related to semantic values.
'yyls': related to locations.
Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
/* The location stack. */
YYLTYPE yylsa[YYINITDEPTH];
YYLTYPE *yyls;
YYLTYPE *yylsp;
/* The locations where the error started and ended. */
YYLTYPE yyerror_range[3];
YYSIZE_T yystacksize;
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
YYLTYPE yyloc;
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
yyssp = yyss = yyssa;
yyvsp = yyvs = yyvsa;
yylsp = yyls = yylsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
yylsp[0] = yylloc;
goto yysetstate;
/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate. |
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
*yyssp = yystate;
if (yyss + yystacksize - 1 <= yyssp)
{
/* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
YYLTYPE *yyls1 = yyls;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
&yyls1, yysize * sizeof (*yylsp),
&yystacksize);
yyls = yyls1;
yyss = yyss1;
yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
yylsp = yyls + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
YYACCEPT;
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yypact_value_is_default (yyn))
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = yylex ();
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yytable_value_is_error (yyn))
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
/* Discard the shifted token. */
yychar = YYEMPTY;
yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
*++yylsp = yylloc;
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
'$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
/* Default location. */
YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
case 2:
#line 221 "expression.y" /* yacc.c:1663 */
{ (yyval.id) = MkIdentifier(yytext); (yyval.id).loc = (yylsp[0]); }
#line 4071 "expression.ec" /* yacc.c:1663 */
break;
case 4:
#line 227 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpBrackets((yyvsp[-1].list)); (yyval.exp).loc = (yyloc); }
#line 4077 "expression.ec" /* yacc.c:1663 */
break;
case 5:
#line 232 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpIdentifier((yyvsp[0].id)); (yyval.exp).loc = (yyloc); }
#line 4083 "expression.ec" /* yacc.c:1663 */
break;
case 6:
#line 234 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpInstance((yyvsp[0].instance)); (yyval.exp).loc = (yyloc); }
#line 4089 "expression.ec" /* yacc.c:1663 */
break;
case 7:
#line 236 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpConstant(yytext); (yyval.exp).loc = (yyloc); }
#line 4095 "expression.ec" /* yacc.c:1663 */
break;
case 8:
#line 237 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpWideString(yytext); (yyval.exp).loc = (yyloc); }
#line 4101 "expression.ec" /* yacc.c:1663 */
break;
case 9:
#line 239 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpString((yyvsp[0].string)); delete (yyvsp[0].string); (yyval.exp).loc = (yyloc); }
#line 4107 "expression.ec" /* yacc.c:1663 */
break;
case 10:
#line 240 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpIntlString((yyvsp[0].string), null); delete (yyvsp[0].string); (yyval.exp).loc = (yyloc); }
#line 4113 "expression.ec" /* yacc.c:1663 */
break;
case 11:
#line 241 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpIntlString((yyvsp[0].string), (yyvsp[-2].string)); delete (yyvsp[-2].string); delete (yyvsp[0].string); (yyval.exp).loc = (yyloc); }
#line 4119 "expression.ec" /* yacc.c:1663 */
break;
case 12:
#line 243 "expression.y" /* yacc.c:1663 */
{ Expression exp = MkExpDummy(); exp.loc.start = (yylsp[-1]).end; exp.loc.end = (yylsp[0]).start; (yyval.exp) = MkExpBrackets(MkListOne(exp)); (yyval.exp).loc = (yyloc); yyerror(); }
#line 4125 "expression.ec" /* yacc.c:1663 */
break;
case 13:
#line 245 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpNew(MkTypeName((yyvsp[-4].list),(yyvsp[-3].declarator)), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4131 "expression.ec" /* yacc.c:1663 */
break;
case 14:
#line 246 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpNew(MkTypeName((yyvsp[-3].list),null), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4137 "expression.ec" /* yacc.c:1663 */
break;
case 15:
#line 247 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpNew0(MkTypeName((yyvsp[-4].list),(yyvsp[-3].declarator)), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4143 "expression.ec" /* yacc.c:1663 */
break;
case 16:
#line 248 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpNew0(MkTypeName((yyvsp[-3].list),null), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4149 "expression.ec" /* yacc.c:1663 */
break;
case 17:
#line 249 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpRenew((yyvsp[-5].exp), MkTypeName((yyvsp[-4].list),(yyvsp[-3].declarator)), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4155 "expression.ec" /* yacc.c:1663 */
break;
case 18:
#line 250 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpRenew((yyvsp[-4].exp), MkTypeName((yyvsp[-3].list),null), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4161 "expression.ec" /* yacc.c:1663 */
break;
case 19:
#line 251 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpRenew0((yyvsp[-5].exp), MkTypeName((yyvsp[-4].list),(yyvsp[-3].declarator)), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4167 "expression.ec" /* yacc.c:1663 */
break;
case 20:
#line 252 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpRenew0((yyvsp[-4].exp), MkTypeName((yyvsp[-3].list),null), (yyvsp[-1].exp)); (yyval.exp).loc = (yyloc); }
#line 4173 "expression.ec" /* yacc.c:1663 */
break;
case 21:
#line 253 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpDummy(); yyerror(); }
#line 4179 "expression.ec" /* yacc.c:1663 */
break;
case 22:
#line 257 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpInstance((yyvsp[0].instance)); (yyval.exp).loc = (yyloc); }
#line 4185 "expression.ec" /* yacc.c:1663 */
break;
case 24:
#line 262 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpIndex((yyvsp[-3].exp), (yyvsp[-1].list)); (yyval.exp).loc = (yyloc); }
#line 4191 "expression.ec" /* yacc.c:1663 */
break;
case 25:
#line 263 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpCall((yyvsp[-2].exp), MkList()); (yyval.exp).call.argLoc.start = (yylsp[-1]).start; (yyval.exp).call.argLoc.end = (yylsp[0]).end; (yyval.exp).loc = (yyloc); }
#line 4197 "expression.ec" /* yacc.c:1663 */
break;
case 26:
#line 264 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpCall((yyvsp[-3].exp), (yyvsp[-1].list)); (yyval.exp).call.argLoc.start = (yylsp[-2]).start; (yyval.exp).call.argLoc.end = (yylsp[0]).end; (yyval.exp).loc = (yyloc); }
#line 4203 "expression.ec" /* yacc.c:1663 */
break;
case 27:
#line 265 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpMember((yyvsp[-2].exp), (yyvsp[0].id)); (yyval.exp).loc = (yyloc); }
#line 4209 "expression.ec" /* yacc.c:1663 */
break;
case 28:
#line 267 "expression.y" /* yacc.c:1663 */
{
char * constant = (yyvsp[-1].exp).type == constantExp ? (yyvsp[-1].exp).constant : null;
int len = constant ? strlen(constant) : 0;
if(constant && constant[len-1] == '.')
{
constant[len-1] = 0;
(yyval.exp) = MkExpMember((yyvsp[-1].exp), (yyvsp[0].id));
(yyval.exp).loc = (yyloc);
}
else
yyerror();
}
#line 4226 "expression.ec" /* yacc.c:1663 */
break;
case 29:
#line 279 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpPointer((yyvsp[-2].exp), (yyvsp[0].id)); (yyval.exp).loc = (yyloc); }
#line 4232 "expression.ec" /* yacc.c:1663 */
break;
case 30:
#line 280 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-1].exp), INC_OP, null); (yyval.exp).loc = (yyloc); }
#line 4238 "expression.ec" /* yacc.c:1663 */
break;
case 31:
#line 281 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-1].exp), DEC_OP, null); (yyval.exp).loc = (yyloc); }
#line 4244 "expression.ec" /* yacc.c:1663 */
break;
case 32:
#line 311 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].exp)); }
#line 4250 "expression.ec" /* yacc.c:1663 */
break;
case 33:
#line 312 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].exp)); }
#line 4256 "expression.ec" /* yacc.c:1663 */
break;
case 34:
#line 313 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].exp)); }
#line 4262 "expression.ec" /* yacc.c:1663 */
break;
case 35:
#line 314 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].exp)); }
#line 4268 "expression.ec" /* yacc.c:1663 */
break;
case 36:
#line 318 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp(null, INC_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4274 "expression.ec" /* yacc.c:1663 */
break;
case 37:
#line 319 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp(null, DEC_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4280 "expression.ec" /* yacc.c:1663 */
break;
case 38:
#line 320 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp(null, (yyvsp[-1].i), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4286 "expression.ec" /* yacc.c:1663 */
break;
case 39:
#line 323 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp(null, SIZEOF, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4292 "expression.ec" /* yacc.c:1663 */
break;
case 40:
#line 324 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpTypeSize((yyvsp[-1].typeName)); (yyval.exp).loc = (yyloc); }
#line 4298 "expression.ec" /* yacc.c:1663 */
break;
case 41:
#line 327 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp(null, ALIGNOF, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4304 "expression.ec" /* yacc.c:1663 */
break;
case 42:
#line 328 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpTypeAlign((yyvsp[-1].typeName)); (yyval.exp).loc = (yyloc); }
#line 4310 "expression.ec" /* yacc.c:1663 */
break;
case 45:
#line 342 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '&'; }
#line 4316 "expression.ec" /* yacc.c:1663 */
break;
case 46:
#line 343 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '*'; }
#line 4322 "expression.ec" /* yacc.c:1663 */
break;
case 47:
#line 344 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '+'; }
#line 4328 "expression.ec" /* yacc.c:1663 */
break;
case 48:
#line 345 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '-'; }
#line 4334 "expression.ec" /* yacc.c:1663 */
break;
case 49:
#line 346 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '~'; }
#line 4340 "expression.ec" /* yacc.c:1663 */
break;
case 50:
#line 347 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '!'; }
#line 4346 "expression.ec" /* yacc.c:1663 */
break;
case 51:
#line 348 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = DELETE; }
#line 4352 "expression.ec" /* yacc.c:1663 */
break;
case 53:
#line 353 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpCast((yyvsp[-2].typeName), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4358 "expression.ec" /* yacc.c:1663 */
break;
case 55:
#line 358 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '*', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4364 "expression.ec" /* yacc.c:1663 */
break;
case 56:
#line 359 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '/', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4370 "expression.ec" /* yacc.c:1663 */
break;
case 57:
#line 360 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '%', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4376 "expression.ec" /* yacc.c:1663 */
break;
case 59:
#line 365 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '+', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4382 "expression.ec" /* yacc.c:1663 */
break;
case 60:
#line 366 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '-', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4388 "expression.ec" /* yacc.c:1663 */
break;
case 62:
#line 371 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), LEFT_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4394 "expression.ec" /* yacc.c:1663 */
break;
case 63:
#line 372 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), RIGHT_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4400 "expression.ec" /* yacc.c:1663 */
break;
case 65:
#line 377 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '<', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4406 "expression.ec" /* yacc.c:1663 */
break;
case 66:
#line 378 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '>', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4412 "expression.ec" /* yacc.c:1663 */
break;
case 67:
#line 379 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), LE_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4418 "expression.ec" /* yacc.c:1663 */
break;
case 68:
#line 380 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), GE_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4424 "expression.ec" /* yacc.c:1663 */
break;
case 70:
#line 385 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), EQ_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4430 "expression.ec" /* yacc.c:1663 */
break;
case 71:
#line 386 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), NE_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4436 "expression.ec" /* yacc.c:1663 */
break;
case 73:
#line 391 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '&', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4442 "expression.ec" /* yacc.c:1663 */
break;
case 75:
#line 396 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '^', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4448 "expression.ec" /* yacc.c:1663 */
break;
case 77:
#line 401 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), '|', (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4454 "expression.ec" /* yacc.c:1663 */
break;
case 79:
#line 406 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), AND_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4460 "expression.ec" /* yacc.c:1663 */
break;
case 81:
#line 411 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), OR_OP, (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4466 "expression.ec" /* yacc.c:1663 */
break;
case 83:
#line 416 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpCondition((yyvsp[-4].exp), (yyvsp[-2].list), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4472 "expression.ec" /* yacc.c:1663 */
break;
case 85:
#line 421 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), (yyvsp[-1].i), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4478 "expression.ec" /* yacc.c:1663 */
break;
case 86:
#line 422 "expression.y" /* yacc.c:1663 */
{ yyerror(); (yyval.exp) = MkExpOp((yyvsp[-2].exp), (yyvsp[-1].i), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4484 "expression.ec" /* yacc.c:1663 */
break;
case 87:
#line 424 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), (yyvsp[-1].i), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4490 "expression.ec" /* yacc.c:1663 */
break;
case 88:
#line 425 "expression.y" /* yacc.c:1663 */
{ (yyval.exp) = MkExpOp((yyvsp[-2].exp), (yyvsp[-1].i), (yyvsp[0].exp)); (yyval.exp).loc = (yyloc); }
#line 4496 "expression.ec" /* yacc.c:1663 */
break;
case 89:
#line 429 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = '='; }
#line 4502 "expression.ec" /* yacc.c:1663 */
break;
case 90:
#line 430 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = MUL_ASSIGN; }
#line 4508 "expression.ec" /* yacc.c:1663 */
break;
case 91:
#line 431 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = DIV_ASSIGN; }
#line 4514 "expression.ec" /* yacc.c:1663 */
break;
case 92:
#line 432 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = MOD_ASSIGN; }
#line 4520 "expression.ec" /* yacc.c:1663 */
break;
case 93:
#line 433 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = ADD_ASSIGN; }
#line 4526 "expression.ec" /* yacc.c:1663 */
break;
case 94:
#line 434 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = SUB_ASSIGN; }
#line 4532 "expression.ec" /* yacc.c:1663 */
break;
case 95:
#line 435 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = LEFT_ASSIGN; }
#line 4538 "expression.ec" /* yacc.c:1663 */
break;
case 96:
#line 436 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = RIGHT_ASSIGN; }
#line 4544 "expression.ec" /* yacc.c:1663 */
break;
case 97:
#line 437 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = AND_ASSIGN; }
#line 4550 "expression.ec" /* yacc.c:1663 */
break;
case 98:
#line 438 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = XOR_ASSIGN; }
#line 4556 "expression.ec" /* yacc.c:1663 */
break;
case 99:
#line 439 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = OR_ASSIGN; }
#line 4562 "expression.ec" /* yacc.c:1663 */
break;
case 100:
#line 443 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].exp)); }
#line 4568 "expression.ec" /* yacc.c:1663 */
break;
case 101:
#line 444 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].exp)); }
#line 4574 "expression.ec" /* yacc.c:1663 */
break;
case 103:
#line 452 "expression.y" /* yacc.c:1663 */
{ (yyval.declaration) = MkDeclaration((yyvsp[-1].list), null); (yyval.declaration).loc = (yyloc); }
#line 4580 "expression.ec" /* yacc.c:1663 */
break;
case 104:
#line 453 "expression.y" /* yacc.c:1663 */
{ (yyval.declaration) = MkDeclaration((yyvsp[-2].list), (yyvsp[-1].list)); (yyval.declaration).loc = (yyloc); }
#line 4586 "expression.ec" /* yacc.c:1663 */
break;
case 105:
#line 454 "expression.y" /* yacc.c:1663 */
{ (yyval.declaration) = MkDeclarationInst((yyvsp[-1].instance)); (yyval.declaration).loc = (yyloc); }
#line 4592 "expression.ec" /* yacc.c:1663 */
break;
case 106:
#line 455 "expression.y" /* yacc.c:1663 */
{ (yyval.declaration) = MkDeclarationDefine((yyvsp[-3].id), (yyvsp[-1].exp)); (yyval.declaration).loc = (yyloc); }
#line 4598 "expression.ec" /* yacc.c:1663 */
break;
case 107:
#line 459 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4604 "expression.ec" /* yacc.c:1663 */
break;
case 108:
#line 460 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4610 "expression.ec" /* yacc.c:1663 */
break;
case 109:
#line 461 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4616 "expression.ec" /* yacc.c:1663 */
break;
case 110:
#line 462 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4622 "expression.ec" /* yacc.c:1663 */
break;
case 111:
#line 463 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4628 "expression.ec" /* yacc.c:1663 */
break;
case 112:
#line 464 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4634 "expression.ec" /* yacc.c:1663 */
break;
case 113:
#line 465 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4640 "expression.ec" /* yacc.c:1663 */
break;
case 114:
#line 466 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4646 "expression.ec" /* yacc.c:1663 */
break;
case 115:
#line 470 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4652 "expression.ec" /* yacc.c:1663 */
break;
case 116:
#line 471 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4658 "expression.ec" /* yacc.c:1663 */
break;
case 117:
#line 472 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4664 "expression.ec" /* yacc.c:1663 */
break;
case 118:
#line 473 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4670 "expression.ec" /* yacc.c:1663 */
break;
case 119:
#line 474 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4676 "expression.ec" /* yacc.c:1663 */
break;
case 120:
#line 475 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4682 "expression.ec" /* yacc.c:1663 */
break;
case 121:
#line 476 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4688 "expression.ec" /* yacc.c:1663 */
break;
case 122:
#line 477 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4694 "expression.ec" /* yacc.c:1663 */
break;
case 123:
#line 478 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4700 "expression.ec" /* yacc.c:1663 */
break;
case 124:
#line 479 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4706 "expression.ec" /* yacc.c:1663 */
break;
case 125:
#line 484 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4712 "expression.ec" /* yacc.c:1663 */
break;
case 126:
#line 485 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4718 "expression.ec" /* yacc.c:1663 */
break;
case 127:
#line 486 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4724 "expression.ec" /* yacc.c:1663 */
break;
case 128:
#line 487 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4730 "expression.ec" /* yacc.c:1663 */
break;
case 129:
#line 488 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4736 "expression.ec" /* yacc.c:1663 */
break;
case 130:
#line 489 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4742 "expression.ec" /* yacc.c:1663 */
break;
case 131:
#line 490 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4748 "expression.ec" /* yacc.c:1663 */
break;
case 132:
#line 491 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4754 "expression.ec" /* yacc.c:1663 */
break;
case 133:
#line 495 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4760 "expression.ec" /* yacc.c:1663 */
break;
case 134:
#line 496 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4766 "expression.ec" /* yacc.c:1663 */
break;
case 135:
#line 497 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4772 "expression.ec" /* yacc.c:1663 */
break;
case 136:
#line 498 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4778 "expression.ec" /* yacc.c:1663 */
break;
case 137:
#line 499 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4784 "expression.ec" /* yacc.c:1663 */
break;
case 138:
#line 500 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4790 "expression.ec" /* yacc.c:1663 */
break;
case 139:
#line 501 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4796 "expression.ec" /* yacc.c:1663 */
break;
case 140:
#line 502 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4802 "expression.ec" /* yacc.c:1663 */
break;
case 141:
#line 503 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 4808 "expression.ec" /* yacc.c:1663 */
break;
case 142:
#line 504 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 4814 "expression.ec" /* yacc.c:1663 */
break;
case 143:
#line 508 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].initDeclarator)); }
#line 4820 "expression.ec" /* yacc.c:1663 */
break;
case 144:
#line 509 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].initDeclarator)); }
#line 4826 "expression.ec" /* yacc.c:1663 */
break;
case 145:
#line 513 "expression.y" /* yacc.c:1663 */
{ (yyval.initDeclarator) = MkInitDeclarator((yyvsp[0].declarator), null); (yyval.initDeclarator).loc = (yyloc); }
#line 4832 "expression.ec" /* yacc.c:1663 */
break;
case 146:
#line 514 "expression.y" /* yacc.c:1663 */
{ (yyval.initDeclarator) = MkInitDeclarator((yyvsp[-2].declarator), (yyvsp[0].initializer)); (yyval.initDeclarator).loc = (yyloc); (yyval.initDeclarator).initializer.loc.start = (yylsp[-1]).end; }
#line 4838 "expression.ec" /* yacc.c:1663 */
break;
case 147:
#line 518 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(TYPEDEF); }
#line 4844 "expression.ec" /* yacc.c:1663 */
break;
case 148:
#line 519 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(EXTERN); }
#line 4850 "expression.ec" /* yacc.c:1663 */
break;
case 149:
#line 520 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(STATIC); }
#line 4856 "expression.ec" /* yacc.c:1663 */
break;
case 150:
#line 521 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(AUTO); }
#line 4862 "expression.ec" /* yacc.c:1663 */
break;
case 151:
#line 522 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(REGISTER); }
#line 4868 "expression.ec" /* yacc.c:1663 */
break;
case 152:
#line 523 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(THREAD); }
#line 4874 "expression.ec" /* yacc.c:1663 */
break;
case 153:
#line 527 "expression.y" /* yacc.c:1663 */
{ (yyval.extDecl) = MkExtDeclString(CopyString(yytext)); }
#line 4880 "expression.ec" /* yacc.c:1663 */
break;
case 154:
#line 528 "expression.y" /* yacc.c:1663 */
{ (yyval.extDecl) = MkExtDeclAttrib((yyvsp[0].attrib)); }
#line 4886 "expression.ec" /* yacc.c:1663 */
break;
case 155:
#line 529 "expression.y" /* yacc.c:1663 */
{ (yyval.extDecl) = MkExtDeclMultiAttrib((yyvsp[0].list)); }
#line 4892 "expression.ec" /* yacc.c:1663 */
break;
case 156:
#line 533 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = ATTRIB; }
#line 4898 "expression.ec" /* yacc.c:1663 */
break;
case 157:
#line 534 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = ATTRIB_DEP; }
#line 4904 "expression.ec" /* yacc.c:1663 */
break;
case 158:
#line 535 "expression.y" /* yacc.c:1663 */
{ (yyval.i) = __ATTRIB; }
#line 4910 "expression.ec" /* yacc.c:1663 */
break;
case 159:
#line 540 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 4916 "expression.ec" /* yacc.c:1663 */
break;
case 160:
#line 541 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 4922 "expression.ec" /* yacc.c:1663 */
break;
case 161:
#line 542 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 4928 "expression.ec" /* yacc.c:1663 */
break;
case 162:
#line 543 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 4934 "expression.ec" /* yacc.c:1663 */
break;
case 163:
#line 544 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 4940 "expression.ec" /* yacc.c:1663 */
break;
case 164:
#line 548 "expression.y" /* yacc.c:1663 */
{ (yyval.attribute) = MkAttribute((yyvsp[0].string), null); (yyval.attribute).loc = (yyloc); }
#line 4946 "expression.ec" /* yacc.c:1663 */
break;
case 165:
#line 549 "expression.y" /* yacc.c:1663 */
{ (yyval.attribute) = MkAttribute((yyvsp[-3].string), MkExpBrackets((yyvsp[-1].list))); (yyval.attribute).loc = (yyloc); }
#line 4952 "expression.ec" /* yacc.c:1663 */
break;
case 166:
#line 553 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkListOne((yyvsp[0].attribute)); }
#line 4958 "expression.ec" /* yacc.c:1663 */
break;
case 167:
#line 554 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].attribute)); (yyval.list) = (yyvsp[-1].list); }
#line 4964 "expression.ec" /* yacc.c:1663 */
break;
case 168:
#line 555 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-2].list), (yyvsp[0].attribute)); (yyval.list) = (yyvsp[-2].list); }
#line 4970 "expression.ec" /* yacc.c:1663 */
break;
case 169:
#line 559 "expression.y" /* yacc.c:1663 */
{ (yyval.attrib) = MkAttrib((yyvsp[-5].i), (yyvsp[-2].list)); (yyval.attrib).loc = (yyloc); }
#line 4976 "expression.ec" /* yacc.c:1663 */
break;
case 170:
#line 560 "expression.y" /* yacc.c:1663 */
{ (yyval.attrib) = MkAttrib((yyvsp[-4].i), null); (yyval.attrib).loc = (yyloc); }
#line 4982 "expression.ec" /* yacc.c:1663 */
break;
case 171:
#line 564 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkListOne((yyvsp[0].attrib)); }
#line 4988 "expression.ec" /* yacc.c:1663 */
break;
case 172:
#line 565 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), (yyvsp[0].attrib)); (yyval.list) = (yyvsp[-1].list); }
#line 4994 "expression.ec" /* yacc.c:1663 */
break;
case 173:
#line 568 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(CONST); }
#line 5000 "expression.ec" /* yacc.c:1663 */
break;
case 174:
#line 569 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(VOLATILE); }
#line 5006 "expression.ec" /* yacc.c:1663 */
break;
case 175:
#line 570 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifierExtended(MkExtDeclString(CopyString(yytext))); }
#line 5012 "expression.ec" /* yacc.c:1663 */
break;
case 176:
#line 574 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = (yyvsp[0].specifier); }
#line 5018 "expression.ec" /* yacc.c:1663 */
break;
case 177:
#line 599 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifierName(yytext); }
#line 5024 "expression.ec" /* yacc.c:1663 */
break;
case 178:
#line 603 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(VOID); }
#line 5030 "expression.ec" /* yacc.c:1663 */
break;
case 179:
#line 604 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(CHAR); }
#line 5036 "expression.ec" /* yacc.c:1663 */
break;
case 180:
#line 605 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(SHORT); }
#line 5042 "expression.ec" /* yacc.c:1663 */
break;
case 181:
#line 606 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT); }
#line 5048 "expression.ec" /* yacc.c:1663 */
break;
case 182:
#line 607 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(UINT); }
#line 5054 "expression.ec" /* yacc.c:1663 */
break;
case 183:
#line 608 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT64); }
#line 5060 "expression.ec" /* yacc.c:1663 */
break;
case 184:
#line 609 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT128); }
#line 5066 "expression.ec" /* yacc.c:1663 */
break;
case 185:
#line 610 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(FLOAT128); }
#line 5072 "expression.ec" /* yacc.c:1663 */
break;
case 186:
#line 611 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(VALIST); }
#line 5078 "expression.ec" /* yacc.c:1663 */
break;
case 187:
#line 612 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(LONG); }
#line 5084 "expression.ec" /* yacc.c:1663 */
break;
case 188:
#line 613 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(FLOAT); }
#line 5090 "expression.ec" /* yacc.c:1663 */
break;
case 189:
#line 614 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(DOUBLE); }
#line 5096 "expression.ec" /* yacc.c:1663 */
break;
case 190:
#line 615 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(SIGNED); }
#line 5102 "expression.ec" /* yacc.c:1663 */
break;
case 191:
#line 616 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(UNSIGNED); }
#line 5108 "expression.ec" /* yacc.c:1663 */
break;
case 192:
#line 617 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(EXTENSION); }
#line 5114 "expression.ec" /* yacc.c:1663 */
break;
case 193:
#line 618 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(_BOOL); }
#line 5120 "expression.ec" /* yacc.c:1663 */
break;
case 194:
#line 619 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(BOOL); }
#line 5126 "expression.ec" /* yacc.c:1663 */
break;
case 198:
#line 623 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifierSubClass((yyvsp[-1].specifier)); }
#line 5132 "expression.ec" /* yacc.c:1663 */
break;
case 199:
#line 624 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(THISCLASS); }
#line 5138 "expression.ec" /* yacc.c:1663 */
break;
case 200:
#line 628 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(VOID); }
#line 5144 "expression.ec" /* yacc.c:1663 */
break;
case 201:
#line 629 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(CHAR); }
#line 5150 "expression.ec" /* yacc.c:1663 */
break;
case 202:
#line 630 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(SHORT); }
#line 5156 "expression.ec" /* yacc.c:1663 */
break;
case 203:
#line 631 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT); }
#line 5162 "expression.ec" /* yacc.c:1663 */
break;
case 204:
#line 632 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(UINT); }
#line 5168 "expression.ec" /* yacc.c:1663 */
break;
case 205:
#line 633 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT64); }
#line 5174 "expression.ec" /* yacc.c:1663 */
break;
case 206:
#line 634 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(INT128); }
#line 5180 "expression.ec" /* yacc.c:1663 */
break;
case 207:
#line 635 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(FLOAT128); }
#line 5186 "expression.ec" /* yacc.c:1663 */
break;
case 208:
#line 636 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(VALIST); }
#line 5192 "expression.ec" /* yacc.c:1663 */
break;
case 209:
#line 637 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(LONG); }
#line 5198 "expression.ec" /* yacc.c:1663 */
break;
case 210:
#line 638 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(FLOAT); }
#line 5204 "expression.ec" /* yacc.c:1663 */
break;
case 211:
#line 639 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(DOUBLE); }
#line 5210 "expression.ec" /* yacc.c:1663 */
break;
case 212:
#line 640 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(SIGNED); }
#line 5216 "expression.ec" /* yacc.c:1663 */
break;
case 213:
#line 641 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(UNSIGNED); }
#line 5222 "expression.ec" /* yacc.c:1663 */
break;
case 214:
#line 642 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(_BOOL); }
#line 5228 "expression.ec" /* yacc.c:1663 */
break;
case 215:
#line 643 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(BOOL); }
#line 5234 "expression.ec" /* yacc.c:1663 */
break;
case 219:
#line 647 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifierSubClass((yyvsp[-1].specifier)); }
#line 5240 "expression.ec" /* yacc.c:1663 */
break;
case 220:
#line 648 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkSpecifier(THISCLASS); }
#line 5246 "expression.ec" /* yacc.c:1663 */
break;
case 221:
#line 653 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-4].specifierType), (yyvsp[-3].id), (yyvsp[-1].list)); if(declMode) DeclClass((yyvsp[-3].id)._class, (yyvsp[-3].id).string); }
#line 5252 "expression.ec" /* yacc.c:1663 */
break;
case 222:
#line 654 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-3].specifierType), null, (yyvsp[-1].list)); }
#line 5258 "expression.ec" /* yacc.c:1663 */
break;
case 223:
#line 655 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-3].specifierType), (yyvsp[-2].id), null); if(declMode) DeclClass((yyvsp[-2].id)._class, (yyvsp[-2].id).string); }
#line 5264 "expression.ec" /* yacc.c:1663 */
break;
case 224:
#line 656 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-2].specifierType), null, null); }
#line 5270 "expression.ec" /* yacc.c:1663 */
break;
case 225:
#line 658 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-4].specifierType), MkIdentifier((yyvsp[-3].specifier).name), (yyvsp[-1].list)); if(declMode) DeclClass((yyvsp[-3].specifier).nsSpec, (yyvsp[-3].specifier).name); FreeSpecifier((yyvsp[-3].specifier)); }
#line 5276 "expression.ec" /* yacc.c:1663 */
break;
case 226:
#line 660 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-5].specifierType), (yyvsp[-3].id), (yyvsp[-1].list)); (yyval.specifier).extDeclStruct = (yyvsp[-4].extDecl); if(declMode) DeclClass((yyvsp[-3].id)._class, (yyvsp[-3].id).string); }
#line 5282 "expression.ec" /* yacc.c:1663 */
break;
case 227:
#line 661 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-4].specifierType), null, (yyvsp[-1].list)); (yyval.specifier).extDeclStruct = (yyvsp[-3].extDecl); }
#line 5288 "expression.ec" /* yacc.c:1663 */
break;
case 228:
#line 662 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-4].specifierType), (yyvsp[-2].id), null); (yyval.specifier).extDeclStruct = (yyvsp[-3].extDecl); if(declMode) DeclClass((yyvsp[-2].id)._class, (yyvsp[-2].id).string); }
#line 5294 "expression.ec" /* yacc.c:1663 */
break;
case 229:
#line 663 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-3].specifierType), null, null); (yyval.specifier).extDeclStruct = (yyvsp[-2].extDecl); }
#line 5300 "expression.ec" /* yacc.c:1663 */
break;
case 230:
#line 665 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-5].specifierType), MkIdentifier((yyvsp[-3].specifier).name), (yyvsp[-1].list)); (yyval.specifier).extDeclStruct = (yyvsp[-4].extDecl); if(declMode) DeclClass((yyvsp[-3].specifier).nsSpec, (yyvsp[-3].specifier).name); FreeSpecifier((yyvsp[-3].specifier)); }
#line 5306 "expression.ec" /* yacc.c:1663 */
break;
case 231:
#line 669 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-1].specifierType), (yyvsp[0].id), null); if(declMode) DeclClass((yyvsp[0].id)._class, (yyvsp[0].id).string); }
#line 5312 "expression.ec" /* yacc.c:1663 */
break;
case 232:
#line 671 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-1].specifierType), MkIdentifier((yyvsp[0].specifier).name), null); if(declMode) DeclClass((yyvsp[0].specifier).nsSpec, (yyvsp[0].specifier).name); FreeSpecifier((yyvsp[0].specifier)); }
#line 5318 "expression.ec" /* yacc.c:1663 */
break;
case 233:
#line 674 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-2].specifierType), (yyvsp[0].id), null); (yyval.specifier).extDeclStruct = (yyvsp[-1].extDecl);if(declMode) DeclClass((yyvsp[0].id)._class, (yyvsp[0].id).string); }
#line 5324 "expression.ec" /* yacc.c:1663 */
break;
case 234:
#line 676 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkStructOrUnion((yyvsp[-2].specifierType), MkIdentifier((yyvsp[0].specifier).name), null); (yyval.specifier).extDeclStruct = (yyvsp[-1].extDecl); if(declMode) DeclClass((yyvsp[0].specifier).nsSpec, (yyvsp[0].specifier).name); FreeSpecifier((yyvsp[0].specifier)); }
#line 5330 "expression.ec" /* yacc.c:1663 */
break;
case 235:
#line 680 "expression.y" /* yacc.c:1663 */
{ (yyval.specifierType) = structSpecifier; }
#line 5336 "expression.ec" /* yacc.c:1663 */
break;
case 236:
#line 681 "expression.y" /* yacc.c:1663 */
{ (yyval.specifierType) = unionSpecifier; }
#line 5342 "expression.ec" /* yacc.c:1663 */
break;
case 237:
#line 685 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].classDef)); }
#line 5348 "expression.ec" /* yacc.c:1663 */
break;
case 238:
#line 686 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].classDef)); }
#line 5354 "expression.ec" /* yacc.c:1663 */
break;
case 239:
#line 690 "expression.y" /* yacc.c:1663 */
{ (yyval.memberInit) = MkMemberInitExp((yyvsp[-2].exp), (yyvsp[0].initializer)); (yyval.memberInit).loc = (yyloc); (yyval.memberInit).realLoc = (yyloc); (yyval.memberInit).initializer.loc.start = (yylsp[-1]).end; }
#line 5360 "expression.ec" /* yacc.c:1663 */
break;
case 240:
#line 694 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].memberInit)); ((MemberInit)(yyval.list)->last).loc = (yyloc); }
#line 5366 "expression.ec" /* yacc.c:1663 */
break;
case 241:
#line 695 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ((MemberInit)(yyvsp[-2].list)->last).loc.end = (yylsp[0]).start; ListAdd((yyvsp[-2].list), (yyvsp[0].memberInit)); }
#line 5372 "expression.ec" /* yacc.c:1663 */
break;
case 242:
#line 700 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-7].list), null, (yyvsp[-6].id), (yyvsp[-3].stmt), (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5378 "expression.ec" /* yacc.c:1663 */
break;
case 243:
#line 702 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-7].list), null, (yyvsp[-6].id), (yyvsp[-1].stmt), (yyvsp[-3].stmt)); (yyval.prop).loc = (yyloc); }
#line 5384 "expression.ec" /* yacc.c:1663 */
break;
case 244:
#line 704 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-5].list), null, (yyvsp[-4].id), (yyvsp[-1].stmt), null); (yyval.prop).loc = (yyloc); }
#line 5390 "expression.ec" /* yacc.c:1663 */
break;
case 245:
#line 706 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-5].list), null, (yyvsp[-4].id), null, (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5396 "expression.ec" /* yacc.c:1663 */
break;
case 246:
#line 708 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-3].list), null, (yyvsp[-2].id), null, null); (yyval.prop).loc = (yyloc); }
#line 5402 "expression.ec" /* yacc.c:1663 */
break;
case 247:
#line 711 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-8].list), (yyvsp[-7].declarator), (yyvsp[-6].id), (yyvsp[-3].stmt), (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5408 "expression.ec" /* yacc.c:1663 */
break;
case 248:
#line 713 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-8].list), (yyvsp[-7].declarator), (yyvsp[-6].id), (yyvsp[-1].stmt), (yyvsp[-3].stmt)); (yyval.prop).loc = (yyloc); }
#line 5414 "expression.ec" /* yacc.c:1663 */
break;
case 249:
#line 715 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-6].list), (yyvsp[-5].declarator), (yyvsp[-4].id), (yyvsp[-1].stmt), null); (yyval.prop).loc = (yyloc); }
#line 5420 "expression.ec" /* yacc.c:1663 */
break;
case 250:
#line 717 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-6].list), (yyvsp[-5].declarator), (yyvsp[-4].id), null, (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5426 "expression.ec" /* yacc.c:1663 */
break;
case 251:
#line 719 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-4].list), (yyvsp[-3].declarator), (yyvsp[-2].id), null, null); (yyval.prop).loc = (yyloc); }
#line 5432 "expression.ec" /* yacc.c:1663 */
break;
case 252:
#line 722 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-6].list), null, null, (yyvsp[-3].stmt), (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5438 "expression.ec" /* yacc.c:1663 */
break;
case 253:
#line 724 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-6].list), null, null, (yyvsp[-1].stmt), (yyvsp[-3].stmt)); (yyval.prop).loc = (yyloc); }
#line 5444 "expression.ec" /* yacc.c:1663 */
break;
case 254:
#line 726 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-4].list), null, null, (yyvsp[-1].stmt), null); (yyval.prop).loc = (yyloc); }
#line 5450 "expression.ec" /* yacc.c:1663 */
break;
case 255:
#line 728 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-4].list), null, null, null, (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5456 "expression.ec" /* yacc.c:1663 */
break;
case 256:
#line 730 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-2].list), null, null, null, null); (yyval.prop).loc = (yyloc); }
#line 5462 "expression.ec" /* yacc.c:1663 */
break;
case 257:
#line 733 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-7].list), (yyvsp[-6].declarator), null, (yyvsp[-3].stmt), (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5468 "expression.ec" /* yacc.c:1663 */
break;
case 258:
#line 735 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-7].list), (yyvsp[-6].declarator), null, (yyvsp[-1].stmt), (yyvsp[-3].stmt)); (yyval.prop).loc = (yyloc); }
#line 5474 "expression.ec" /* yacc.c:1663 */
break;
case 259:
#line 737 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-5].list), (yyvsp[-4].declarator), null, (yyvsp[-1].stmt), null); (yyval.prop).loc = (yyloc); }
#line 5480 "expression.ec" /* yacc.c:1663 */
break;
case 260:
#line 739 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-5].list), (yyvsp[-4].declarator), null, null, (yyvsp[-1].stmt)); (yyval.prop).loc = (yyloc); }
#line 5486 "expression.ec" /* yacc.c:1663 */
break;
case 261:
#line 741 "expression.y" /* yacc.c:1663 */
{ (yyval.prop) = MkProperty((yyvsp[-3].list), (yyvsp[-2].declarator), null, null, null); (yyval.prop).loc = (yyloc); }
#line 5492 "expression.ec" /* yacc.c:1663 */
break;
case 262:
#line 745 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefDeclaration(MkStructDeclaration((yyvsp[-2].list), (yyvsp[-1].list), null)); (yyval.classDef).decl.loc = (yyloc); (yyval.classDef).loc = (yyloc); }
#line 5498 "expression.ec" /* yacc.c:1663 */
break;
case 263:
#line 746 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefDeclaration(MkStructDeclaration((yyvsp[-1].list), null, null)); (yyval.classDef).decl.loc = (yyloc); (yyval.classDef).loc = (yyloc); }
#line 5504 "expression.ec" /* yacc.c:1663 */
break;
case 264:
#line 747 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefDeclaration(MkDeclarationClassInst((yyvsp[-1].instance))); (yyval.classDef).loc = (yyloc); (yyval.classDef).decl.loc = (yyloc); }
#line 5510 "expression.ec" /* yacc.c:1663 */
break;
case 265:
#line 748 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefDeclaration(MkDeclarationClassInst((yyvsp[-1].instance))); (yyval.classDef).loc = (yyloc); (yyval.classDef).decl.loc = (yyloc); }
#line 5516 "expression.ec" /* yacc.c:1663 */
break;
case 266:
#line 749 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefFunction((yyvsp[0].classFunction)); (yyval.classDef).loc = (yyloc); }
#line 5522 "expression.ec" /* yacc.c:1663 */
break;
case 267:
#line 750 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefDefaultProperty((yyvsp[-1].list)); if((yyvsp[-1].list)->last) ((MemberInit)(yyvsp[-1].list)->last).loc.end = (yylsp[0]).start; (yyval.classDef).loc = (yyloc); }
#line 5528 "expression.ec" /* yacc.c:1663 */
break;
case 268:
#line 751 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = MkClassDefProperty((yyvsp[0].prop)); (yyval.classDef).loc = (yyloc); }
#line 5534 "expression.ec" /* yacc.c:1663 */
break;
case 269:
#line 752 "expression.y" /* yacc.c:1663 */
{ (yyval.classDef) = null; }
#line 5540 "expression.ec" /* yacc.c:1663 */
break;
case 270:
#line 757 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].declarator)); }
#line 5546 "expression.ec" /* yacc.c:1663 */
break;
case 271:
#line 759 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].declarator)); }
#line 5552 "expression.ec" /* yacc.c:1663 */
break;
case 272:
#line 764 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkStructDeclarator((yyvsp[0].declarator), null); (yyval.declarator).loc = (yyloc); }
#line 5558 "expression.ec" /* yacc.c:1663 */
break;
case 273:
#line 766 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkStructDeclarator((yyvsp[-1].declarator), null); (yyval.declarator).structDecl.attrib = (yyvsp[0].attrib); (yyval.declarator).loc = (yyloc); }
#line 5564 "expression.ec" /* yacc.c:1663 */
break;
case 274:
#line 768 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkStructDeclarator(null, (yyvsp[0].exp)); (yyval.declarator).loc = (yyloc); }
#line 5570 "expression.ec" /* yacc.c:1663 */
break;
case 275:
#line 770 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkStructDeclarator((yyvsp[-2].declarator), (yyvsp[0].exp)); (yyval.declarator).loc = (yyloc); }
#line 5576 "expression.ec" /* yacc.c:1663 */
break;
case 276:
#line 772 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkStructDeclarator((yyvsp[-4].declarator), (yyvsp[-2].exp)); (yyval.declarator).structDecl.posExp = (yyvsp[0].exp); (yyval.declarator).loc = (yyloc); }
#line 5582 "expression.ec" /* yacc.c:1663 */
break;
case 277:
#line 776 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum((yyvsp[0].id), null); if(declMode) DeclClass((yyvsp[0].id)._class, (yyvsp[0].id).string); }
#line 5588 "expression.ec" /* yacc.c:1663 */
break;
case 278:
#line 777 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum(MkIdentifier((yyvsp[0].specifier).name), null); if(declMode) DeclClass((yyvsp[0].specifier).nsSpec, (yyvsp[0].specifier).name); FreeSpecifier((yyvsp[0].specifier)); }
#line 5594 "expression.ec" /* yacc.c:1663 */
break;
case 279:
#line 782 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum(null, (yyvsp[-1].list)); }
#line 5600 "expression.ec" /* yacc.c:1663 */
break;
case 280:
#line 783 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum((yyvsp[-3].id), (yyvsp[-1].list)); if(declMode) DeclClass((yyvsp[-3].id)._class, (yyvsp[-3].id).string); }
#line 5606 "expression.ec" /* yacc.c:1663 */
break;
case 281:
#line 784 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum((yyvsp[-5].id), (yyvsp[-3].list)); (yyval.specifier).definitions = (yyvsp[-1].list); if(declMode) DeclClass((yyvsp[-5].id)._class, (yyvsp[-5].id).string); }
#line 5612 "expression.ec" /* yacc.c:1663 */
break;
case 282:
#line 785 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum(MkIdentifier((yyvsp[-5].specifier).name), (yyvsp[-3].list)); (yyval.specifier).definitions = (yyvsp[-1].list); if(declMode) DeclClass((yyvsp[-5].specifier).nsSpec, (yyvsp[-5].specifier).name); FreeSpecifier((yyvsp[-5].specifier)); }
#line 5618 "expression.ec" /* yacc.c:1663 */
break;
case 283:
#line 786 "expression.y" /* yacc.c:1663 */
{ (yyval.specifier) = MkEnum(MkIdentifier((yyvsp[-3].specifier).name), (yyvsp[-1].list)); if(declMode) DeclClass((yyvsp[-3].specifier).nsSpec, (yyvsp[-3].specifier).name); FreeSpecifier((yyvsp[-3].specifier)); }
#line 5624 "expression.ec" /* yacc.c:1663 */
break;
case 284:
#line 791 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].enumerator)); }
#line 5630 "expression.ec" /* yacc.c:1663 */
break;
case 285:
#line 793 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].enumerator)); }
#line 5636 "expression.ec" /* yacc.c:1663 */
break;
case 286:
#line 798 "expression.y" /* yacc.c:1663 */
{ (yyval.enumerator) = MkEnumerator((yyvsp[0].id), null, null); }
#line 5642 "expression.ec" /* yacc.c:1663 */
break;
case 287:
#line 800 "expression.y" /* yacc.c:1663 */
{ (yyval.enumerator) = MkEnumerator((yyvsp[-2].id), (yyvsp[0].exp), null); }
#line 5648 "expression.ec" /* yacc.c:1663 */
break;
case 288:
#line 801 "expression.y" /* yacc.c:1663 */
{ (yyval.enumerator) = MkEnumerator((yyvsp[-1].id), null, (yyvsp[0].list)); }
#line 5654 "expression.ec" /* yacc.c:1663 */
break;
case 289:
#line 802 "expression.y" /* yacc.c:1663 */
{ (yyval.enumerator) = MkEnumerator((yyvsp[-3].id), (yyvsp[0].exp), (yyvsp[-2].list)); }
#line 5660 "expression.ec" /* yacc.c:1663 */
break;
case 290:
#line 808 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorBrackets((yyvsp[-1].declarator)); }
#line 5666 "expression.ec" /* yacc.c:1663 */
break;
case 291:
#line 810 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray(null, null); }
#line 5672 "expression.ec" /* yacc.c:1663 */
break;
case 292:
#line 812 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray(null, (yyvsp[-1].exp)); }
#line 5678 "expression.ec" /* yacc.c:1663 */
break;
case 293:
#line 814 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorEnumArray(null, (yyvsp[-1].specifier)); }
#line 5684 "expression.ec" /* yacc.c:1663 */
break;
case 294:
#line 816 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray((yyvsp[-2].declarator), null); }
#line 5690 "expression.ec" /* yacc.c:1663 */
break;
case 295:
#line 818 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray((yyvsp[-3].declarator), (yyvsp[-1].exp)); }
#line 5696 "expression.ec" /* yacc.c:1663 */
break;
case 296:
#line 820 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorEnumArray((yyvsp[-3].declarator), (yyvsp[-1].specifier)); }
#line 5702 "expression.ec" /* yacc.c:1663 */
break;
case 297:
#line 822 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction(null, null); }
#line 5708 "expression.ec" /* yacc.c:1663 */
break;
case 298:
#line 824 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction(null, (yyvsp[-1].list)); }
#line 5714 "expression.ec" /* yacc.c:1663 */
break;
case 299:
#line 826 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-2].declarator), null); }
#line 5720 "expression.ec" /* yacc.c:1663 */
break;
case 300:
#line 828 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-3].declarator), (yyvsp[-1].list)); }
#line 5726 "expression.ec" /* yacc.c:1663 */
break;
case 301:
#line 833 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorBrackets((yyvsp[-1].declarator)); }
#line 5732 "expression.ec" /* yacc.c:1663 */
break;
case 302:
#line 835 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction(null, null); }
#line 5738 "expression.ec" /* yacc.c:1663 */
break;
case 303:
#line 837 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction(null, (yyvsp[-1].list)); }
#line 5744 "expression.ec" /* yacc.c:1663 */
break;
case 304:
#line 839 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-2].declarator), null); }
#line 5750 "expression.ec" /* yacc.c:1663 */
break;
case 305:
#line 841 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-3].declarator), (yyvsp[-1].list)); }
#line 5756 "expression.ec" /* yacc.c:1663 */
break;
case 306:
#line 845 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[0].pointer), null); }
#line 5762 "expression.ec" /* yacc.c:1663 */
break;
case 308:
#line 847 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator)); }
#line 5768 "expression.ec" /* yacc.c:1663 */
break;
case 309:
#line 848 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), MkDeclaratorPointer((yyvsp[0].pointer), null)); }
#line 5774 "expression.ec" /* yacc.c:1663 */
break;
case 310:
#line 849 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator)); }
#line 5780 "expression.ec" /* yacc.c:1663 */
break;
case 311:
#line 850 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-2].extDecl), MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator))); }
#line 5786 "expression.ec" /* yacc.c:1663 */
break;
case 312:
#line 854 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[0].pointer), null); }
#line 5792 "expression.ec" /* yacc.c:1663 */
break;
case 314:
#line 856 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator)); }
#line 5798 "expression.ec" /* yacc.c:1663 */
break;
case 315:
#line 857 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), MkDeclaratorPointer((yyvsp[0].pointer), null)); }
#line 5804 "expression.ec" /* yacc.c:1663 */
break;
case 316:
#line 858 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator)); }
#line 5810 "expression.ec" /* yacc.c:1663 */
break;
case 317:
#line 859 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-2].extDecl), MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator))); }
#line 5816 "expression.ec" /* yacc.c:1663 */
break;
case 319:
#line 907 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator)); }
#line 5822 "expression.ec" /* yacc.c:1663 */
break;
case 320:
#line 909 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-2].extDecl), MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator))); }
#line 5828 "expression.ec" /* yacc.c:1663 */
break;
case 321:
#line 915 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorIdentifier((yyvsp[0].id)); }
#line 5834 "expression.ec" /* yacc.c:1663 */
break;
case 322:
#line 917 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorBrackets((yyvsp[-1].declarator)); }
#line 5840 "expression.ec" /* yacc.c:1663 */
break;
case 323:
#line 919 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray((yyvsp[-3].declarator), (yyvsp[-1].exp)); }
#line 5846 "expression.ec" /* yacc.c:1663 */
break;
case 324:
#line 921 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorArray((yyvsp[-2].declarator), null); }
#line 5852 "expression.ec" /* yacc.c:1663 */
break;
case 325:
#line 923 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorEnumArray((yyvsp[-3].declarator), (yyvsp[-1].specifier)); }
#line 5858 "expression.ec" /* yacc.c:1663 */
break;
case 327:
#line 929 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator)); }
#line 5864 "expression.ec" /* yacc.c:1663 */
break;
case 328:
#line 932 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator)); }
#line 5870 "expression.ec" /* yacc.c:1663 */
break;
case 329:
#line 934 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-2].extDecl), MkDeclaratorPointer((yyvsp[-1].pointer), (yyvsp[0].declarator))); }
#line 5876 "expression.ec" /* yacc.c:1663 */
break;
case 330:
#line 936 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorPointer((yyvsp[-2].pointer), MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator))); }
#line 5882 "expression.ec" /* yacc.c:1663 */
break;
case 333:
#line 944 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator)); }
#line 5888 "expression.ec" /* yacc.c:1663 */
break;
case 334:
#line 946 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorExtended((yyvsp[-1].extDecl), (yyvsp[0].declarator)); }
#line 5894 "expression.ec" /* yacc.c:1663 */
break;
case 336:
#line 955 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-2].declarator), (yyvsp[-1].list)); }
#line 5900 "expression.ec" /* yacc.c:1663 */
break;
case 337:
#line 957 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-2].declarator), (yyvsp[-1].list)); }
#line 5906 "expression.ec" /* yacc.c:1663 */
break;
case 338:
#line 959 "expression.y" /* yacc.c:1663 */
{ (yyval.declarator) = MkDeclaratorFunction((yyvsp[-1].declarator), null); }
#line 5912 "expression.ec" /* yacc.c:1663 */
break;
case 339:
#line 963 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].specifier)); }
#line 5918 "expression.ec" /* yacc.c:1663 */
break;
case 340:
#line 964 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].specifier)); }
#line 5924 "expression.ec" /* yacc.c:1663 */
break;
case 341:
#line 968 "expression.y" /* yacc.c:1663 */
{ (yyval.pointer) = MkPointer(null, null); }
#line 5930 "expression.ec" /* yacc.c:1663 */
break;
case 342:
#line 969 "expression.y" /* yacc.c:1663 */
{ (yyval.pointer) = MkPointer((yyvsp[0].list), null); }
#line 5936 "expression.ec" /* yacc.c:1663 */
break;
case 343:
#line 970 "expression.y" /* yacc.c:1663 */
{ (yyval.pointer) = MkPointer(null, (yyvsp[0].pointer)); }
#line 5942 "expression.ec" /* yacc.c:1663 */
break;
case 344:
#line 971 "expression.y" /* yacc.c:1663 */
{ (yyval.pointer) = MkPointer((yyvsp[-1].list), (yyvsp[0].pointer)); }
#line 5948 "expression.ec" /* yacc.c:1663 */
break;
case 346:
#line 976 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), MkTypeName(null, null)); }
#line 5954 "expression.ec" /* yacc.c:1663 */
break;
case 347:
#line 980 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].typeName)); }
#line 5960 "expression.ec" /* yacc.c:1663 */
break;
case 348:
#line 981 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].typeName)); }
#line 5966 "expression.ec" /* yacc.c:1663 */
break;
case 349:
#line 985 "expression.y" /* yacc.c:1663 */
{ (yyval.typeName) = MkTypeName((yyvsp[-1].list), (yyvsp[0].declarator)); }
#line 5972 "expression.ec" /* yacc.c:1663 */
break;
case 350:
#line 986 "expression.y" /* yacc.c:1663 */
{ (yyval.typeName) = MkTypeName((yyvsp[-1].list), (yyvsp[0].declarator)); }
#line 5978 "expression.ec" /* yacc.c:1663 */
break;
case 351:
#line 987 "expression.y" /* yacc.c:1663 */
{ (yyval.typeName) = MkTypeName((yyvsp[0].list), null); }
#line 5984 "expression.ec" /* yacc.c:1663 */
break;
case 352:
#line 991 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), MkTypeName(null, MkDeclaratorIdentifier((yyvsp[0].id)))); }
#line 5990 "expression.ec" /* yacc.c:1663 */
break;
case 353:
#line 992 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), MkTypeName(null, MkDeclaratorIdentifier((yyvsp[0].id)))); }
#line 5996 "expression.ec" /* yacc.c:1663 */
break;
case 354:
#line 996 "expression.y" /* yacc.c:1663 */
{ (yyval.typeName) = MkTypeName((yyvsp[0].list), null); }
#line 6002 "expression.ec" /* yacc.c:1663 */
break;
case 355:
#line 997 "expression.y" /* yacc.c:1663 */
{ (yyval.typeName) = MkTypeName((yyvsp[-1].list), (yyvsp[0].declarator)); }
#line 6008 "expression.ec" /* yacc.c:1663 */
break;
case 356:
#line 1007 "expression.y" /* yacc.c:1663 */
{ (yyval.initializer) = MkInitializerAssignment((yyvsp[0].exp)); (yyval.initializer).loc = (yyloc); }
#line 6014 "expression.ec" /* yacc.c:1663 */
break;
case 357:
#line 1009 "expression.y" /* yacc.c:1663 */
{ (yyval.initializer) = MkInitializerList((yyvsp[-1].list)); (yyval.initializer).loc = (yyloc); }
#line 6020 "expression.ec" /* yacc.c:1663 */
break;
case 358:
#line 1011 "expression.y" /* yacc.c:1663 */
{
(yyval.initializer) = MkInitializerList((yyvsp[-2].list));
(yyval.initializer).loc = (yyloc);
{
Expression exp = MkExpDummy();
Initializer init = MkInitializerAssignment(exp);
init.loc = (yylsp[-1]);
exp.loc = (yylsp[-1]);
ListAdd((yyvsp[-2].list), init);
}
}
#line 6037 "expression.ec" /* yacc.c:1663 */
break;
case 359:
#line 1026 "expression.y" /* yacc.c:1663 */
{ (yyval.initializer) = MkInitializerAssignment((yyvsp[0].exp)); (yyval.initializer).loc = (yyloc); }
#line 6043 "expression.ec" /* yacc.c:1663 */
break;
case 360:
#line 1028 "expression.y" /* yacc.c:1663 */
{ (yyval.initializer) = MkInitializerAssignment((yyvsp[0].exp)); (yyval.initializer).loc = (yyloc); }
#line 6049 "expression.ec" /* yacc.c:1663 */
break;
case 361:
#line 1049 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].initializer)); }
#line 6055 "expression.ec" /* yacc.c:1663 */
break;
case 362:
#line 1051 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-2].list); ListAdd((yyvsp[-2].list), (yyvsp[0].initializer)); }
#line 6061 "expression.ec" /* yacc.c:1663 */
break;
case 369:
#line 1065 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkLabeledStmt((yyvsp[-2].id), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6067 "expression.ec" /* yacc.c:1663 */
break;
case 370:
#line 1067 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkCaseStmt((yyvsp[-2].exp), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); (yyvsp[-2].exp).loc.start = (yylsp[-3]).end; }
#line 6073 "expression.ec" /* yacc.c:1663 */
break;
case 371:
#line 1069 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkCaseStmt(null, (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6079 "expression.ec" /* yacc.c:1663 */
break;
case 372:
#line 1073 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].declaration)); }
#line 6085 "expression.ec" /* yacc.c:1663 */
break;
case 373:
#line 1074 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].declaration)); }
#line 6091 "expression.ec" /* yacc.c:1663 */
break;
case 374:
#line 1078 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].stmt)); }
#line 6097 "expression.ec" /* yacc.c:1663 */
break;
case 375:
#line 1079 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = (yyvsp[-1].list); ListAdd((yyvsp[-1].list), (yyvsp[0].stmt)); }
#line 6103 "expression.ec" /* yacc.c:1663 */
break;
case 376:
#line 1082 "expression.y" /* yacc.c:1663 */
{ Statement stmt = MkBadDeclStmt((yyvsp[0].declaration)); stmt.loc = (yylsp[0]); /*yyerror(); */ ListAdd((yyvsp[-1].list), stmt); (yyval.list) = (yyvsp[-1].list); }
#line 6109 "expression.ec" /* yacc.c:1663 */
break;
case 377:
#line 1086 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkCompoundStmt(null, (yyvsp[0].list)); }
#line 6115 "expression.ec" /* yacc.c:1663 */
break;
case 378:
#line 1087 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkCompoundStmt((yyvsp[0].list), null); }
#line 6121 "expression.ec" /* yacc.c:1663 */
break;
case 379:
#line 1088 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkCompoundStmt((yyvsp[-1].list), (yyvsp[0].list)); }
#line 6127 "expression.ec" /* yacc.c:1663 */
break;
case 380:
#line 1092 "expression.y" /* yacc.c:1663 */
{ (yyval.context) = PushContext(); }
#line 6133 "expression.ec" /* yacc.c:1663 */
break;
case 381:
#line 1097 "expression.y" /* yacc.c:1663 */
{
(yyval.stmt) = MkCompoundStmt(null, null);
(yyval.stmt).compound.context = PushContext();
PopContext((yyval.stmt).compound.context);
(yyval.stmt).loc = (yyloc);
}
#line 6144 "expression.ec" /* yacc.c:1663 */
break;
case 382:
#line 1105 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = (yyvsp[-1].stmt); (yyval.stmt).compound.context = (yyvsp[-2].context); PopContext((yyvsp[-2].context)); (yyval.stmt).loc = (yyloc); }
#line 6150 "expression.ec" /* yacc.c:1663 */
break;
case 383:
#line 1109 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkExpressionStmt(null); (yyval.stmt).loc = (yyloc); }
#line 6156 "expression.ec" /* yacc.c:1663 */
break;
case 384:
#line 1110 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkExpressionStmt((yyvsp[-1].list)); (yyval.stmt).loc = (yyloc); }
#line 6162 "expression.ec" /* yacc.c:1663 */
break;
case 385:
#line 1114 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkIfStmt((yyvsp[-2].list), (yyvsp[0].stmt), null); (yyval.stmt).loc = (yyloc); }
#line 6168 "expression.ec" /* yacc.c:1663 */
break;
case 386:
#line 1115 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkIfStmt((yyvsp[-4].list), (yyvsp[-2].stmt), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6174 "expression.ec" /* yacc.c:1663 */
break;
case 387:
#line 1116 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkSwitchStmt((yyvsp[-2].list), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6180 "expression.ec" /* yacc.c:1663 */
break;
case 388:
#line 1120 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkWhileStmt((yyvsp[-2].list), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6186 "expression.ec" /* yacc.c:1663 */
break;
case 389:
#line 1121 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkDoWhileStmt((yyvsp[-5].stmt), (yyvsp[-2].list)); (yyval.stmt).loc = (yyloc); }
#line 6192 "expression.ec" /* yacc.c:1663 */
break;
case 390:
#line 1122 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkForStmt((yyvsp[-3].stmt), (yyvsp[-2].stmt), null, (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6198 "expression.ec" /* yacc.c:1663 */
break;
case 391:
#line 1123 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkForStmt((yyvsp[-4].stmt), (yyvsp[-3].stmt), (yyvsp[-2].list), (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6204 "expression.ec" /* yacc.c:1663 */
break;
case 392:
#line 1125 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkWhileStmt(null, (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6210 "expression.ec" /* yacc.c:1663 */
break;
case 393:
#line 1126 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkForStmt((yyvsp[-2].stmt), null, null, (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6216 "expression.ec" /* yacc.c:1663 */
break;
case 394:
#line 1127 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkForStmt(null, null, null, (yyvsp[0].stmt)); (yyval.stmt).loc = (yyloc); }
#line 6222 "expression.ec" /* yacc.c:1663 */
break;
case 395:
#line 1131 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkGotoStmt((yyvsp[-1].id)); (yyval.stmt).loc = (yyloc); }
#line 6228 "expression.ec" /* yacc.c:1663 */
break;
case 396:
#line 1132 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkContinueStmt(); (yyval.stmt).loc = (yyloc); }
#line 6234 "expression.ec" /* yacc.c:1663 */
break;
case 397:
#line 1133 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkBreakStmt(); (yyval.stmt).loc = (yyloc); }
#line 6240 "expression.ec" /* yacc.c:1663 */
break;
case 398:
#line 1134 "expression.y" /* yacc.c:1663 */
{ Expression exp = MkExpDummy(); (yyval.stmt) = MkReturnStmt(MkListOne(exp)); (yyval.stmt).loc = (yyloc); exp.loc = (yylsp[0]); }
#line 6246 "expression.ec" /* yacc.c:1663 */
break;
case 399:
#line 1135 "expression.y" /* yacc.c:1663 */
{ (yyval.stmt) = MkReturnStmt((yyvsp[-1].list)); (yyval.stmt).loc = (yyloc); }
#line 6252 "expression.ec" /* yacc.c:1663 */
break;
case 400:
#line 1139 "expression.y" /* yacc.c:1663 */
{ (yyval.string) = CopyString(yytext); }
#line 6258 "expression.ec" /* yacc.c:1663 */
break;
case 401:
#line 1144 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiationNamed((yyvsp[-4].list), MkExpIdentifier((yyvsp[-3].id)), (yyvsp[-1].list)); (yyval.instance).loc = (yyloc); (yyval.instance).nameLoc = (yylsp[-3]); (yyval.instance).insideLoc.start = (yylsp[-2]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start;}
#line 6264 "expression.ec" /* yacc.c:1663 */
break;
case 402:
#line 1146 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiationNamed((yyvsp[-3].list), MkExpIdentifier((yyvsp[-2].id)), MkList()); (yyval.instance).loc = (yyloc); (yyval.instance).nameLoc = (yylsp[-2]); (yyval.instance).insideLoc.start = (yylsp[-1]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start;}
#line 6270 "expression.ec" /* yacc.c:1663 */
break;
case 403:
#line 1151 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiation((yyvsp[-3].specifier), null, (yyvsp[-1].list)); (yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-2]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start; }
#line 6276 "expression.ec" /* yacc.c:1663 */
break;
case 404:
#line 1153 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiation((yyvsp[-2].specifier), null, MkList()); (yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-1]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start;}
#line 6282 "expression.ec" /* yacc.c:1663 */
break;
case 405:
#line 1155 "expression.y" /* yacc.c:1663 */
{ Location tmpLoc = yylloc; yylloc = (yylsp[-3]); yylloc = tmpLoc; (yyval.instance) = MkInstantiation(MkSpecifierName((yyvsp[-3].id).string), null, (yyvsp[-1].list));(yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-2]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start; FreeIdentifier((yyvsp[-3].id)); }
#line 6288 "expression.ec" /* yacc.c:1663 */
break;
case 406:
#line 1157 "expression.y" /* yacc.c:1663 */
{ Location tmpLoc = yylloc; yylloc = (yylsp[-2]); yylloc = tmpLoc; (yyval.instance) = MkInstantiation(MkSpecifierName((yyvsp[-2].id).string), null, MkList()); (yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-1]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start; FreeIdentifier((yyvsp[-2].id)); }
#line 6294 "expression.ec" /* yacc.c:1663 */
break;
case 407:
#line 1162 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiation(null, null, (yyvsp[-1].list)); (yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-2]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start; }
#line 6300 "expression.ec" /* yacc.c:1663 */
break;
case 408:
#line 1164 "expression.y" /* yacc.c:1663 */
{ (yyval.instance) = MkInstantiation(null, null, MkList()); (yyval.instance).loc = (yyloc); (yyval.instance).insideLoc.start = (yylsp[-1]).end; (yyval.instance).insideLoc.end = (yylsp[0]).start;}
#line 6306 "expression.ec" /* yacc.c:1663 */
break;
case 409:
#line 1169 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction((yyvsp[-1].list), null, (yyvsp[0].declarator), null); (yyval.classFunction).loc = (yyloc); }
#line 6312 "expression.ec" /* yacc.c:1663 */
break;
case 410:
#line 1171 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction(null, null, (yyvsp[0].declarator), null); (yyval.classFunction).loc = (yyloc); }
#line 6318 "expression.ec" /* yacc.c:1663 */
break;
case 411:
#line 1176 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction(null, null, null, null); (yyval.classFunction).isConstructor = true; (yyval.classFunction).loc = (yyloc); FreeList /*FreeSpecifier*/((yyvsp[-2].list), FreeSpecifier); }
#line 6324 "expression.ec" /* yacc.c:1663 */
break;
case 412:
#line 1181 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction(null, null, null, null); (yyval.classFunction).isDestructor = true; (yyval.classFunction).loc = (yyloc); FreeList /*FreeSpecifier*/((yyvsp[-2].list), FreeSpecifier); }
#line 6330 "expression.ec" /* yacc.c:1663 */
break;
case 413:
#line 1186 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction((yyvsp[-1].list), null, (yyvsp[0].declarator), null); (yyval.classFunction).isVirtual = true; (yyval.classFunction).loc = (yyloc); }
#line 6336 "expression.ec" /* yacc.c:1663 */
break;
case 414:
#line 1188 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction(null, null, (yyvsp[0].declarator), null); (yyval.classFunction).isVirtual = true; (yyval.classFunction).loc = (yyloc); }
#line 6342 "expression.ec" /* yacc.c:1663 */
break;
case 415:
#line 1193 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), (yyvsp[0].stmt)); (yyval.classFunction).loc = (yyloc); }
#line 6348 "expression.ec" /* yacc.c:1663 */
break;
case 416:
#line 1195 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), (yyvsp[0].stmt)); (yyval.classFunction).loc = (yyloc); }
#line 6354 "expression.ec" /* yacc.c:1663 */
break;
case 417:
#line 1197 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), null); (yyval.classFunction).loc = (yyloc); }
#line 6360 "expression.ec" /* yacc.c:1663 */
break;
case 418:
#line 1199 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), (yyvsp[0].stmt)); (yyval.classFunction).loc = (yyloc); }
#line 6366 "expression.ec" /* yacc.c:1663 */
break;
case 419:
#line 1201 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), (yyvsp[0].stmt)); (yyval.classFunction).loc = (yyloc); }
#line 6372 "expression.ec" /* yacc.c:1663 */
break;
case 420:
#line 1207 "expression.y" /* yacc.c:1663 */
{ (yyval.classFunction) = MkClassFunction((yyvsp[-1].list), null, (yyvsp[0].declarator), null); (yyval.classFunction).loc = (yyloc); }
#line 6378 "expression.ec" /* yacc.c:1663 */
break;
case 421:
#line 1212 "expression.y" /* yacc.c:1663 */
{ ProcessClassFunctionBody((yyvsp[-1].classFunction), (yyvsp[0].stmt)); (yyval.classFunction).loc = (yyloc); }
#line 6384 "expression.ec" /* yacc.c:1663 */
break;
case 422:
#line 1216 "expression.y" /* yacc.c:1663 */
{ (yyval.memberInit) = MkMemberInitExp((yyvsp[-2].exp), (yyvsp[0].initializer)); (yyval.memberInit).loc = (yyloc); (yyval.memberInit).realLoc = (yyloc); (yyval.memberInit).initializer.loc.start = (yylsp[-1]).end;}
#line 6390 "expression.ec" /* yacc.c:1663 */
break;
case 423:
#line 1217 "expression.y" /* yacc.c:1663 */
{ (yyval.memberInit) = MkMemberInit(null, (yyvsp[0].initializer)); (yyval.memberInit).loc = (yyloc); (yyval.memberInit).realLoc = (yyloc);}
#line 6396 "expression.ec" /* yacc.c:1663 */
break;
case 424:
#line 1222 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), (yyvsp[0].memberInit)); }
#line 6402 "expression.ec" /* yacc.c:1663 */
break;
case 425:
#line 1224 "expression.y" /* yacc.c:1663 */
{ ((MemberInit)(yyvsp[-2].list)->last).loc.end = (yylsp[0]).start; ListAdd((yyvsp[-2].list), (yyvsp[0].memberInit)); (yyval.list) = (yyvsp[-2].list); }
#line 6408 "expression.ec" /* yacc.c:1663 */
break;
case 426:
#line 1229 "expression.y" /* yacc.c:1663 */
{ if((yyvsp[-1].list)->last) ((MemberInit)(yyvsp[-1].list)->last).loc.end = (yylsp[0]).end; (yyval.list) = (yyvsp[-1].list); }
#line 6414 "expression.ec" /* yacc.c:1663 */
break;
case 427:
#line 1233 "expression.y" /* yacc.c:1663 */
{ MembersInit members = MkMembersInitList((yyvsp[0].list)); (yyval.list) = MkList(); ListAdd((yyval.list), members); members.loc = (yylsp[0]); }
#line 6420 "expression.ec" /* yacc.c:1663 */
break;
case 428:
#line 1234 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), MkMembersInitMethod((yyvsp[0].classFunction))); ((MembersInit)(yyval.list)->last).loc = (yylsp[0]); }
#line 6426 "expression.ec" /* yacc.c:1663 */
break;
case 429:
#line 1235 "expression.y" /* yacc.c:1663 */
{ MembersInit members = MkMembersInitList((yyvsp[0].list)); ListAdd((yyval.list), members); members.loc = (yylsp[0]); (yyval.list) = (yyvsp[-1].list); }
#line 6432 "expression.ec" /* yacc.c:1663 */
break;
case 430:
#line 1236 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyval.list), MkMembersInitMethod((yyvsp[0].classFunction))); ((MembersInit)(yyval.list)->last).loc = (yylsp[0]); (yyval.list) = (yyvsp[-1].list); }
#line 6438 "expression.ec" /* yacc.c:1663 */
break;
case 431:
#line 1237 "expression.y" /* yacc.c:1663 */
{ MembersInit members = MkMembersInitList(MkList()); (yyval.list) = MkList(); ListAdd((yyval.list), members); members.loc = (yylsp[0]); }
#line 6444 "expression.ec" /* yacc.c:1663 */
break;
case 432:
#line 1238 "expression.y" /* yacc.c:1663 */
{ MembersInit members = MkMembersInitList(MkList()); ListAdd((yyval.list), members); members.loc = (yylsp[0]); (yyval.list) = (yyvsp[-1].list); }
#line 6450 "expression.ec" /* yacc.c:1663 */
break;
case 434:
#line 1243 "expression.y" /* yacc.c:1663 */
{ (yyval.list) = MkList(); ListAdd((yyval.list), MkMembersInitList((yyvsp[0].list))); ((MembersInit)(yyval.list)->last).loc = (yylsp[0]); }
#line 6456 "expression.ec" /* yacc.c:1663 */
break;
case 435:
#line 1244 "expression.y" /* yacc.c:1663 */
{ ListAdd((yyvsp[-1].list), MkMembersInitList((yyvsp[0].list))); ((MembersInit)(yyval.list)->last).loc = (yylsp[0]); }
#line 6462 "expression.ec" /* yacc.c:1663 */
break;
case 436:
#line 1248 "expression.y" /* yacc.c:1663 */
{ parsedExpression = (yyvsp[0].exp); }
#line 6468 "expression.ec" /* yacc.c:1663 */
break;
#line 6472 "expression.ec" /* yacc.c:1663 */
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
incorrect destructor might then be invoked immediately. In the
case of YYERROR or YYBACKUP, subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated. */
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
*++yylsp = yyloc;
/* Now 'shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
goto yynewstate;
/*--------------------------------------.
| yyerrlab -- here on detecting error. |
`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)
{
char const *yymsgp = YY_("syntax error");
int yysyntax_error_status;
yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0)
yymsgp = yymsg;
else if (yysyntax_error_status == 1)
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
if (!yymsg)
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = 2;
}
else
{
yysyntax_error_status = YYSYNTAX_ERROR;
yymsgp = yymsg;
}
}
yyerror (yymsgp);
if (yysyntax_error_status == 2)
goto yyexhaustedlab;
}
# undef YYSYNTAX_ERROR
#endif
}
yyerror_range[1] = yylloc;
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval, &yylloc);
yychar = YYEMPTY;
}
}
/* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code. */
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
yyerror_range[1] = yylsp[1-yylen];
/* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yyerror_range[1] = *yylsp;
yydestruct ("Error: popping",
yystos[yystate], yyvsp, yylsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
yyerror_range[2] = yylloc;
/* Using YYLLOC is tempting, but would change the location of
the lookahead. YYLOC is available though. */
YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
*++yylsp = yyloc;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
goto yyreturn;
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
goto yyreturn;
#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
yyreturn:
if (yychar != YYEMPTY)
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval, &yylloc);
}
/* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp, yylsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
return yyresult;
}
#line 1250 "expression.y" /* yacc.c:1923 */
| eC | 3 | mingodad/ecere-sdk | compiler/libec/src/expression.ec | [
"BSD-3-Clause"
] |
{layout '@layout.latte'}
{block title}Source file{/block}
{block content}
<div id="source">
{var $lineCount =substr_count($source, "\n")}
{var $lineRegex = '~<span class="line">(\\s*(\\d+):\\s*)</span>([^\\n]*(?:\\n|$))~'}
<pre class="numbers"><code>{$source|replaceRE:$lineRegex,'<span id="$2" class="l"><a href="#$2">$1</a></span>'|noescape}</code></pre>
<pre class="code"><code>{$source|replaceRE:$lineRegex,'<span class="l" id="line-$2">$3</span>'|noescape}<br></code></pre>
</div>
{/block}
| Latte | 2 | pujak17/tets | packages/ThemeDefault/src/source.latte | [
"MIT"
] |
# this file has been copied by the R-package antaresXpansion
#
# this file should have been copied in the temporary folder of
# current expansion optimisation, i.e.:
# study_path/user/expansion/temp/
#
# all data files are supposed to be located in the same folder
data;
#number of mc years
set YEAR := include in_mc.txt;
#number of weeks
set WEEK := include in_week.txt;
#iteration
set ITERATION := include in_iterations.txt;
#invested capacity in the simulated iterations
param z0 := include in_z0.txt ;
#investment candidates description
param : INV_CANDIDATE : c_inv unit_size max_unit relaxed := include in_candidates.txt ;
param : restrained_lb restrained_ub := include in_out_capacitybounds.txt;
#bender cuts
param : AVG_CUT : c0_avg := include in_avgcuts.txt ;
param : YEARLY_CUT_ALL : c0_yearly := include in_yearlycuts.txt ;
param : WEEKLY_CUT_ALL : c0_weekly := include in_weeklycuts.txt ;
#marg. cost of each investment (as returned by ANTARES)
param lambda_avg := include in_avgrentability.txt ;
param lambda_yearly := include in_yearlyrentability.txt ;
param lambda_weekly := include in_weeklyrentability.txt ;
# uper bound on total costs
param ub_cost := include in_ubcosts.txt;
# options
param prob := include in_yweights.txt;
param : OPTION : option_default_value := include master_default_options.txt;
param : OPTION_REDIFINED : option_new_value = include in_options.txt;
| AMPL | 4 | pelefebvre/antares-xpansion | data_test/test_case_7.1_structure/user/expansion/temp/master_dat.ampl | [
"Apache-2.0"
] |
"""The test for the sensibo select platform."""
from __future__ import annotations
from datetime import timedelta
from unittest.mock import patch
from pysensibo.model import SensiboData
from pytest import MonkeyPatch
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.util import dt
from tests.common import async_fire_time_changed
async def test_sensor(
hass: HomeAssistant,
load_int: ConfigEntry,
monkeypatch: MonkeyPatch,
get_data: SensiboData,
) -> None:
"""Test the Sensibo sensor."""
state1 = hass.states.get("sensor.hallway_motion_sensor_battery_voltage")
state2 = hass.states.get("sensor.kitchen_pm2_5")
state3 = hass.states.get("sensor.kitchen_pure_sensitivity")
assert state1.state == "3000"
assert state2.state == "1"
assert state3.state == "n"
assert state2.attributes == {
"state_class": "measurement",
"unit_of_measurement": "µg/m³",
"device_class": "pm25",
"icon": "mdi:air-filter",
"friendly_name": "Kitchen PM2.5",
}
monkeypatch.setattr(get_data.parsed["AAZZAAZZ"], "pm25", 2)
with patch(
"homeassistant.components.sensibo.coordinator.SensiboClient.async_get_devices_data",
return_value=get_data,
):
async_fire_time_changed(
hass,
dt.utcnow() + timedelta(minutes=5),
)
await hass.async_block_till_done()
state1 = hass.states.get("sensor.kitchen_pm2_5")
assert state1.state == "2"
| Python | 3 | mib1185/core | tests/components/sensibo/test_sensor.py | [
"Apache-2.0"
] |
# Copyright (c) 2018-2021, Carnegie Mellon University
# See LICENSE for details
Class(ScratchpadGlobals, rec(
getOpts := meth(arg)
local lssize, opts, swp, brules, nrules, br, nrsgmts, vlen, globalUnrolling,size, ttype;
lssize := When (Length(arg) >= 2, arg[2], 2);
nrsgmts := When (Length(arg) >= 3, arg[3], 1);
vlen := When (Length(arg) >= 4, arg[4], 1);
size := When (Length(arg) >= 5, arg[5], 2);
ttype := When (Length(arg) >= 6, arg[6], 'R');
swp := When (Length(arg) >= 7, arg[7], false);
globalUnrolling := When(Length(arg) >=8, arg[8], 1);
brules := When(IsRec(SpiralDefaults.breakdownRules),
UserRecFields(SpiralDefaults.breakdownRules),
Filtered(Dir(SpiralDefaults.breakdownRules), i->not i in SystemRecFields));
nrules := rec();
for br in brules do
nrules.(br) := List(SpiralDefaults.breakdownRules.(br), i->CopyFields(i));
od;
opts := CopyFields(SpiralDefaults);
opts.breakdownRules := nrules;
opts.breakdownRules.TCompose := [ TCompose_tag];
opts.breakdownRules.DFT := [DFT_Base, DFT_CT, DFT_tSPL_CT, DFT_PD, DFT_Rader];
opts.breakdownRules.TTwiddle := [ TTwiddle_Tw1];
opts.breakdownRules.WHT := [WHT_tSPL_BinSplit, WHT_Base, WHT_BinSplit];
opts.breakdownRules.TTensor := [AxI_IxB,IxB_AxI];
opts.breakdownRules.TTensorI := Concat([IxA_scratch_push, IxA_base, AxI_base, IxA_L_base, L_IxA_base], [IxA_scratch, AxI_scratch, IxAL_scratch]);
opts.tags := [Cond( ttype = 'R', ALStore(lssize,nrsgmts,vlen), ALStoreCx(lssize,nrsgmts,vlen)) ];
opts.formulaStrategies.sigmaSpl := [ MergedRuleSet(RulesSumsScratch, RulesFuncSimpScratch, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch,RulesII,OLRules) ];
opts.formulaStrategies.preRC := [ MergedRuleSet(RulesSumsScratch, RulesFuncSimpScratch, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch, RulesII, OLRules), (s,o) -> ScratchModel.updateInfo(s) ];
opts.formulaStrategies.rc := [ MergedRuleSet(RulesSums, RulesFuncSimp, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch, RulesII, OLRules) ];
#opts.formulaStrategies.postProcess := [(s, opts) -> compiler.BlockSums(opts.globalUnrolling, s)];
opts.size := size;
opts.swp := swp;
opts.globalUnrolling := globalUnrolling;
opts.sumsgen := ScratchSumsGen;
opts.codegen := ScratchCodegen;
opts.unparser := CScratchUnparserProg;
opts.memModifier := "__memory";
opts.scratchModifier := "__scratch";
opts.arrayDataModifier := "__rom";
opts.romModifier := "__rom";
opts.includes := [];
Add(opts.includes, "\"scratch.h\"");
opts.dmaSignal := (self, opts) >> "DMA_signal";
opts.dmaWait := (self, opts) >> "DMA_wait";
opts.cpuSignal := (self, opts) >> "CPU_signal";
opts.cpuWait := (self, opts) >> "CPU_wait";
opts.dmaFence := (self, opts) >> "DMA_fence";
opts.dmaLoad := (self, opts) >> "DMA_load";
opts.dmaStore := (self, opts) >> "DMA_store";
opts.model := ScratchModel;
return opts;
end
));
| GAP | 3 | sr7cb/spiral-software | namespaces/spiral/paradigms/scratchpad/opts.gi | [
"BSD-2-Clause-FreeBSD"
] |
<!--
NOTE: This template has escaped `\r\n` line-endings markers that will be converted to real `\r\n` line-ending chars when loaded from the test file-system.
This conversion happens in the monkeyPatchReadFile() function, which changes `fs.readFile()`.
-->
<div>\r\n
Some Message\r\n
Encoded character: 🚀\r\n
</div> | HTML | 2 | John-Cassidy/angular | packages/compiler-cli/test/compliance/test_cases/source_mapping/external_templates/escaped_chars.html | [
"MIT"
] |